import random
rastgele = random.randint(1, 10)

while True:
    tahmin = int(input("1-10 arası tahmin: "))
    if tahmin == rastgele:
        print("Doğru tahmin!")
        break
    elif tahmin < rastgele:
        print("Daha büyük bir sayı girin.")
    else:
        print("Daha küçük bir sayı girin.")
        
        --
        
        sayi = int(input("Bir sayı giriniz: "))
asal_mi = True

if sayi < 2:
    asal_mi = False
else:
    for i in range(2, int(sayi ** 0.5) + 1):
        if sayi % i == 0:
            asal_mi = False
            break

if asal_mi:
    print(sayi, "asal bir sayıdır.")
else:
    print(sayi, "asal değildir.")
    
    __
    
    sayi = int(input("Bir sayı giriniz: "))
faktoriyel = 1

if sayi < 0:
    print("Negatif sayıların faktöriyeli tanımsızdır.")
else:
    for i in range(1, sayi + 1):
        faktoriyel *= i
    print(sayi, "sayısının faktöriyeli:", faktoriyel)
    
    __
    
    sayi1 = float(input("Birinci sayıyı giriniz: "))
sayi2 = float(input("İkinci sayıyı giriniz: "))
islem = input("İşlem seçiniz (+, -, *, /): ")

if islem == "+":
    sonuc = sayi1 + sayi2
elif islem == "-":
    sonuc = sayi1 - sayi2
elif islem == "*":
    sonuc = sayi1 * sayi2
elif islem == "/":
    if sayi2 != 0:
        sonuc = sayi1 / sayi2
    else:
        sonuc = "Sıfıra bölme hatası!"
else:
    sonuc = "Geçersiz işlem seçimi!"

print("Sonuç:", sonuc)

__

n = int(input("Kaç terim üretmek istiyorsunuz? "))
a, b = 0, 1
print("Fibonacci Dizisi:")
for i in range(n):
    print(a, end=" ")
    a, b = b, a + b
    __
    def basari_durumu(not_degeri):
    if not_degeri >= 90:
        return "A - Mükemmel"
    elif not_degeri >= 70:
        return "B - Başarılı"
    elif not_degeri >= 50:
        return "C - Geçti"
    else:
        return "F - Kaldı"

ogrenci_notu = int(input("Notunuzu giriniz: "))
sonuc = basari_durumu(ogrenci_notu)
print("Başarı Durumu:", sonuc)

__

# ogrenci_notu_hesapla adında bir fonksiyon tanımlıyoruz
def ogrenci_notu_hesapla(vize, final):
    # Vize notunun %40'ını hesaplıyoruz
    vize_katkisi = vize * 0.40
    # Final notunun %60'ını hesaplıyoruz
    final_katkisi = final * 0.60
    # Toplam ortalamayı hesaplıyoruz
    ortalama = vize_katkisi + final_katkisi
    # Hesaplanan ortalamayı geri döndürüyoruz
    return ortalama

# basari_durumu adında ikinci bir fonksiyon tanımlıyoruz
def basari_durumu(ortalama):
    # Eğer ortalama 50 veya büyükse
    if ortalama >= 50:
        # Başarılı mesajı döndür
        return "Geçti"
    else:
        # Aksi durumda kaldı mesajı döndür
        return "Kaldı"

# Fonksiyonları kullanmak için kullanıcıdan veri alıyoruz
vize_notu = float(input("Vize notunu giriniz: ")) # Kullanıcıdan vize notu al
final_notu = float(input("Final notunu giriniz: ")) # Kullanıcıdan final notu al

# Ortalamayı hesaplıyoruz
sonuc = ogrenci_notu_hesapla(vize_notu, final_notu)

# Başarı durumunu belirliyoruz
durum = basari_durumu(sonuc)

# Sonucu ekrana yazdırıyoruz
print("Ortalama:", sonuc)
print("Durum:", durum)

__

# liste_ortalama adında bir fonksiyon tanımlıyoruz
def liste_ortalama(veri_listesi):
    # Listenin toplamını hesaplamak için başlangıç değeri
    toplam = 0
    # Listenin her elemanı için döngü başlatıyoruz
    for eleman in veri_listesi:
        # Her elemanı toplama ekliyoruz
        toplam = toplam + eleman
    
    # Listenin uzunluğunu hesaplıyoruz
    eleman_sayisi = len(veri_listesi)
    
    # Ortalama hesaplıyoruz
    ortalama = toplam / eleman_sayisi
    
    # Hesaplanan ortalamayı döndürüyoruz
    return ortalama

# Örnek veri listesi oluşturuyoruz
veriler = [10, 20, 30, 40, 50]

# Fonksiyonu çağırıyoruz
sonuc = liste_ortalama(veriler)

# Sonucu yazdırıyoruz
print("Liste Ortalaması:", sonuc)

__

# tahmin_et adında bir fonksiyon tanımlıyoruz
def tahmin_et(calisma_saati):
    # Eğer çalışma saati 5 saat veya daha fazlaysa (Eşik Değeri: 5)
    if calisma_saati >= 5:
        # Başarılı sonucunu döndür
        return "Başarılı"
    else:
        # Aksi durumda başarısız sonucunu döndür
        return "Başarısız"

# Kullanıcıdan günlük çalışma saati alıyoruz
saat = float(input("Günlük çalışma saati giriniz: "))

# Tahmin fonksiyonunu çağırıyoruz
tahmin = tahmin_et(saat)

# Tahmini yazdırıyoruz
print("Tahmin Sonucu:", tahmin)

__

notlar = [45, 70, 90, 55, 30, 85]
eleman_sayisi = len(notlar)
toplam = 0

for not_degeri in notlar:
    toplam = toplam + not_degeri

ortalama = toplam / eleman_sayisi
en_yuksek = max(notlar)
en_dusuk = min(notlar)

basarili_sayisi = 0
for not_degeri in notlar:
    if not_degeri >= 50:
        basarili_sayisi += 1

print("Not Listesi:", notlar)
print("Ortalama:", ortalama)
print("En Yüksek Not:", en_yuksek)
print("Başarılı Öğrenci Sayısı:", basarili_sayisi)

__

# Sözlük Oluşturma
ogrenci = {
    "ad": "Ahmet",
    "yas": 20,
    "bolum": "Bilgisayar Programcılığı",
    "not": 85
}

# Değere Erişim ve Güncelleme
print(ogrenci["ad"])          # Doğrudan erişim
print(ogrenci.get("yas"))     # get() ile güvenli erişim (hata vermez)
ogrenci["not"] = 90           # Değer güncelleme
ogrenci["sehir"] = "İstanbul" # Yeni anahtar ekleme

# Eleman Silme
del ogrenci["yas"]
ogrenci.pop("not")

# Sözlükte Döngüler
for anahtar in ogrenci:
    print(anahtar) # Sadece anahtarlar

for anahtar, deger in ogrenci.items():
    print(anahtar, ":", deger) # Anahtar ve değer birlikte
    
    __
    
    # with bloğu ile güvenli dosya okuma (Otomatik kapatma sağlar)
with open("ornek.txt", "r") as dosya:
    icerik = dosya.read()
    print(icerik)

# Dosyaya Yazma (w: Üzerine yazar, a: Sona ekler)
with open("notlar.txt", "w") as dosya:
    dosya.write("Ahmet 70\n")
    dosya.write("Ayşe 90\n")

# Dosyadan Veri Okuyup İşleme
not_listesi = []
with open("notlar.txt", "r") as dosya:
    satirlar = dosya.readlines()
    for satir in satirlar:
        parcalar = satir.split() # Boşluğa göre böler
        not_degeri = int(parcalar[1])
        not_listesi.append(not_degeri)

print("Ortalama:", sum(not_listesi)/len(not_listesi))

___

pip --version              # Sürüm kontrolü
pip install numpy          # Paket yükleme
pip install numpy --upgrade # Paket güncelleme
pip list                   # Yüklü paketleri listeleme
pip freeze > requirements.txt # Gereksinim dosyası oluşturma

import numpy as np

# Dizi Oluşturma ve Özellikleri
dizi = np.array([10, 20, 30, 40])
print("Şekil:", dizi.shape)
print("Veri Tipi:", dizi.dtype)

# Vektörel İşlemler
a = np.array([1, 2, 3])
b = np.array([10, 20, 30])
print("Toplam:", a + b)

# İstatistiksel Fonksiyonlar
notlar = np.array([70, 90, 50, 85, 60])
print("Ortalama:", np.mean(notlar))
print("Standart Sapma:", np.std(notlar))

__

import pandas as pd

# DataFrame Oluşturma
veri = {
    "isim": ["Ali", "Ayşe", "Mehmet"],
    "not": [70, 90, 50],
    "yas": [20, 21, 19]
}
df = pd.DataFrame(veri)

# Veri Seçme ve Filtreleme
print(df.head(2))          # İlk 2 satır
print(df["isim"])          # Sadece isim sütunu
print(df[df["not"] > 60])  # Notu 60'tan büyük olanlar

# Eksik Veri İşleme
import numpy as np
df["not"].fillna(0, inplace=True) # Boş notları 0 ile doldur

# CSV İşlemleri
df.to_csv("veriler.csv", index=False) # Dosyaya kaydet
yeni_df = pd.read_csv("veriler.csv")  # Dosyadan oku

__
A. Doğrusal Regresyon (Linear Regression)

import numpy as np
from sklearn.linear_model import LinearRegression

# Veri Hazırlama (x: çalışma saati, y: not)
x = np.array([1, 2, 3, 4, 5]).reshape(-1, 1)
y = np.array([40, 50, 60, 70, 80])

# Model Eğitimi
model = LinearRegression()
model.fit(x, y)

# Tahmin (6 saat çalışan öğrenci)
tahmin = model.predict([[6]])
print("Tahmin edilen not:", tahmin) # Çıktı: 90.0

___
B. Lojistik Regresyon (Logistic Regression)
from sklearn.linear_model import LogisticRegression
import numpy as np

x = np.array([1, 2, 3, 4, 5, 6]).reshape(-1, 1)
y = np.array([0, 0, 0, 1, 1, 1]) # 0: Kaldı, 1: Geçti

model = LogisticRegression()
model.fit(x, y)

# Tahmin ve Olasılık Hesaplama
tahmin = model.predict([[4]])
olasilik = model.predict_proba([[4]])
print("Geçti mi (1=Evet):", tahmin)
print("Geçme Olasılığı:", olasilik[0][1])

__
C. Karar Ağaçları (Decision Tree)
from sklearn.tree import DecisionTreeClassifier
import numpy as np

x = np.array([[1], [2], [3], [4], [5], [6]])
y = np.array([0, 0, 0, 1, 1, 1])

model = DecisionTreeClassifier()
model.fit(x, y)

tahmin = model.predict([[3]])
print("Tahmin sonucu:", tahmin)

___
D. K-En Yakın Komşu (KNN)

from sklearn.neighbors import KNeighborsClassifier
import numpy as np

x = np.array([[1], [2], [3], [4], [5], [6]])
y = np.array([0, 0, 0, 1, 1, 1])

model = KNeighborsClassifier(n_neighbors=3) # K=3
model.fit(x, y)

tahmin = model.predict([[4]])
print("KNN Tahmini:", tahmin)

___

E. Naive Bayes
from sklearn.naive_bayes import GaussianNB
import numpy as np

x = np.array([[1], [2], [3], [6], [7], [8]]) # Kelime sayıları
y = np.array([0, 0, 0, 1, 1, 1]) # 0: Spam değil, 1: Spam

model = GaussianNB()
model.fit(x, y)

tahmin = model.predict([[5]])
print("Spam tahmini:", tahmin)

___

4. Model Performans Ölçümü ve Veri Ayrımı

from sklearn.model_selection import train_test_split
from sklearn.metrics import mean_squared_error

# Veriyi ayırma
X_train, X_test, y_train, y_test = train_test_split(x, y, test_size=0.2, random_state=42)

# Hata Hesaplama (MSE)
mse = mean_squared_error(gercek_degerler, tahmin_degerler)
print("Ortalama Kare Hata:", mse)

____

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import confusion_matrix, accuracy_score, classification_report

# 1. VERİ SETİ OLUŞTURMA (Simüle edilmiş örnek veri)
data = {
    'Glikoz': [85, 150, 110, 180, 95, 160, 125, 105, 140, 190],
    'VKI': [22, 35, 28, 40, 24, 38, 30, 26, 32, 42], # Vücut Kitle İndeksi
    'Yas': [25, 45, 30, 55, 22, 50, 35, 28, 40, 60],
    'Diyabet': [0, 1, 0, 1, 0, 1, 0, 0, 1, 1] # 0: Sağlıklı, 1: Hasta
}
df = pd.DataFrame(data)

# 2. ÖZELLİK VE HEDEF BELİRLEME
X = df[['Glikoz', 'VKI', 'Yas']] # Girdiler (Features)
y = df['Diyabet']                # Çıktı (Label)

# 3. EĞİTİM VE TEST AYRIMI (%80 Eğitim, %20 Test)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# 4. VERİ ÖLÇEKLENDİRME (Standardization)
# Lojistik Regresyon gibi modellerde verilerin aynı ölçekte olması önemlidir.
scaler = StandardScaler()
X_train = scaler.fit_transform(X_train)
X_test = scaler.transform(X_test)

# 5. MODEL OLUŞTURMA VE EĞİTİM
model = LogisticRegression()
model.fit(X_train, y_train)

# 6. TAHMİN VE PERFORMANS ANALİZİ
y_pred = model.predict(X_test)

print("--- Model Performans Sonuçları ---")
print(f"Doğruluk (Accuracy) Skoru: {accuracy_score(y_test, y_pred)}")
print("\nKarmaşıklık Matrisi (Confusion Matrix):")
print(confusion_matrix(y_test, y_pred))
print("\nDetaylı Rapor:")
print(classification_report(y_test, y_pred))

# 7. YENİ VERİ İLE TAHMİN
# Yeni bir kişi: Glikoz: 130, VKI: 33, Yaş: 38
yeni_kisi = scaler.transform([[130, 33, 38]])
tahmin = model.predict(yeni_kisi)
olasılık = model.predict_proba(yeni_kisi)

sonuc = "Hasta" if tahmin[0] == 1 else "Sağlıklı"
print(f"\nYeni Kişi Tahmini: {sonuc} (Olasılık: %{olasılık[0][tahmin[0]]*100:.2f})")

__
1. Temel Derin Öğrenme Uygulaması (Öğrenci Geçti/Kaldı)
import numpy as np
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense

# VERİ SETİ
# [çalışma saati, devamsızlık]
X = np.array([
    [1, 5],
    [2, 4],
    [3, 2],
    [4, 1],
    [5, 0]
])

# 0 = kaldı, 1 = geçti
y = np.array([0, 0, 1, 1, 1])

# MODEL OLUŞTURMA
model = Sequential()

# Gizli katman (5 nöron, ReLU aktivasyonu, 2 giriş değişkeni)
model.add(Dense(units=5, activation='relu', input_dim=2))

# Çıkış katmanı (1 nöron, Sigmoid aktivasyonu)
model.add(Dense(units=1, activation='sigmoid'))

# DERLEME
model.compile(
    optimizer='adam',
    loss='binary_crossentropy',
    metrics=['accuracy']
)

# EĞİTİM
model.fit(X, y, epochs=100, verbose=1)

# TAHMİN (Yeni öğrenci: 3 saat çalışma, 1 gün devamsızlık)
tahmin = model.predict(np.array([[3, 1]]))
print("Geçme ihtimali:", tahmin)

__

2. Yapay Sinir Ağı Uygulaması (Obezite Tahmini)

import numpy as np
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense

# VERİ SETİ
# [boy(cm), kilo(kg)]
X = np.array([
    [160, 50],
    [170, 65],
    [180, 90],
    [175, 85],
    [165, 55]
])

# 0 = normal, 1 = obez
y = np.array([0, 0, 1, 1, 0])

# MODEL OLUŞTURMA
model = Sequential()

# Gizli katman
model.add(Dense(units=4, activation='relu', input_dim=2))

# Çıkış katmanı
model.add(Dense(units=1, activation='sigmoid'))

# DERLEME
model.compile(
    optimizer='adam',
    loss='binary_crossentropy',
    metrics=['accuracy']
)

# EĞİTİM
model.fit(X, y, epochs=150, verbose=1)

# TAHMİN (Yeni kişi: 178 cm, 88 kg)
tahmin = model.predict(np.array([[178, 88]]))
print("Obez olma ihtimali:", tahmin)
__

3. Üç Farklı Model Karşılaştırması (Ürün Satın Alma Senaryosu)

import numpy as np
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense

# [yaş, gelir (bin TL)]
X = np.array([
    [18, 3], [22, 4], [25, 5], [30, 6],
    [35, 7], [40, 8], [45, 9], [50, 10]
])

# 0 = satın almaz, 1 = satın alır
y = np.array([0, 0, 0, 1, 1, 1, 1, 1])

model3 = Sequential()
model3.add(Dense(4, activation='tanh', input_dim=2))
model3.add(Dense(1, activation='sigmoid'))

model3.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy'])
model3.fit(X, y, epochs=100, verbose=0)

tahmin3 = model3.predict(np.array([[28, 5]]))
print("Model 3 Tahmin:", tahmin3)

___

4. İris Veri Seti Sınıflandırması (Gelişmiş Uygulama)

import numpy as np
import pandas as pd
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import OneHotEncoder, StandardScaler
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense

# 1. VERİ HAZIRLAMA
iris = load_iris()
X = iris.data
y = iris.target.reshape(-1, 1)

# One-hot encode (3 sınıf -> [1,0,0] vb.)
encoder = OneHotEncoder(sparse_output=False) # Not: yeni sürümlerde sparse_output kullanılır
y_encoded = encoder.fit_transform(y)

# Eğitim ve Test setine ayırma
X_train, X_test, y_train, y_test = train_test_split(X, y_encoded, test_size=0.2, random_state=42)

# Normalizasyon
scaler = StandardScaler()
X_train = scaler.fit_transform(X_train)
X_test = scaler.transform(X_test)

# 2. MODEL OLUŞTURMA
model = Sequential([
    Dense(10, input_dim=4, activation='relu'),
    Dense(10, activation='relu'),
    Dense(3, activation='softmax') # 3 sınıf için softmax
])

model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy'])

# 3. EĞİTİM
history = model.fit(X_train, y_train, epochs=50, batch_size=5, validation_split=0.2)

# 4. TEST VE DEĞERLENDİRME
loss, accuracy = model.evaluate(X_test, y_test)
print(f"Test Loss: {loss:.4f}, Test Accuracy: {accuracy:.4f}")

____

1. Görüntü Okuma ve Boyut Bilgisi Yazdırma

import cv2

# Görüntüyü oku (Resim dosyasının aynı klasörde olduğundan emin olun)
img = cv2.imread("resim.jpg")

# Boyut bilgisi (yükseklik, genişlik, kanal sayısı)
print("Boyut:", img.shape)

# Görüntüyü ekranda göster
cv2.imshow("Orijinal", img)

# Bir tuşa basılana kadar bekle ve pencereleri kapat
cv2.waitKey(0)
cv2.destroyAllWindows()

___

2. Görüntü İşleme: Gri Tonlama, Bulanıklaştırma ve Eşikleme

import cv2

img = cv2.imread("resim.jpg")

# Gri tonlamaya çevirme
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)

# Blur (Gaussian Bulanıklaştırma ile gürültü azaltma)
blur = cv2.GaussianBlur(gray, (5, 5), 0)

# Threshold (Eşikleme ile siyah-beyaz görüntü oluşturma)
ret, thresh = cv2.threshold(blur, 127, 255, cv2.THRESH_BINARY)

# Sonuçları farklı pencerelerde göster
cv2.imshow("Gri", gray)
cv2.imshow("Blur", blur)
cv2.imshow("Threshold", thresh)

cv2.waitKey(0)
cv2.destroyAllWindows()
____
3. Özellik Çıkarma: Kenar Tespiti (Canny)

import cv2

img = cv2.imread("resim.jpg")
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)

# Canny algoritması ile kenar tespiti
edges = cv2.Canny(gray, 100, 200)

cv2.imshow("Orijinal", img)
cv2.imshow("Kenarlar", edges)

cv2.waitKey(0)
cv2.destroyAllWindows()

____

4. Özellik Çıkarma: Köşe Tespiti

import cv2
import numpy as np

img = cv2.imread("resim.jpg")
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
gray = np.float32(gray)

# Köşeleri takip etme fonksiyonu
corners = cv2.goodFeaturesToTrack(gray, 50, 0.01, 10)
corners = np.int0(corners)

# Tespit edilen her köşeye küçük bir daire çiz
for corner in corners:
    x, y = corner.ravel()
    cv2.circle(img, (x, y), 3, (0, 255, 0), -1)

cv2.imshow("Kose Tespiti", img)
cv2.waitKey(0)
cv2.destroyAllWindows()

___

5. Nesne Tespiti: Haar Cascade ile Yüz Tespiti
import cv2

# Haar Cascade modelini yükle
face_cascade = cv2.CascadeClassifier(cv2.data.haarcascades + "haarcascade_frontalface_default.xml")

img = cv2.imread("insan.jpg")
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)

# Yüzleri tespit et
faces = face_cascade.detectMultiScale(gray, 1.3, 5)

# Her yüz için dikdörtgen çiz
for (x, y, w, h) in faces:
    cv2.rectangle(img, (x, y), (x + w, y + h), (255, 0, 0), 2)

cv2.imshow("Yuz Tespiti", img)
cv2.waitKey(0)
cv2.destroyAllWindows()
___

6. Görüntü Sınıflandırma: Basit SVM Uygulaması

from sklearn.svm import SVC

# Örnek özellik verisi (X) ve etiketler (y)
X = [[1, 1], [1, 0], [0, 1], [0, 0]]
y = ["kedi", "kopek", "kopek", "kedi"]

# Modeli oluştur ve eğit
model = SVC()
model.fit(X, y)

# Yeni bir veri için tahmin yap
print("Tahmin:", model.predict([[1, 1]]))

____

7. Uygulama: Görüntü Üzerinde Çoklu İşlem (Gri, Kenar, Yüz)

import cv2

img = cv2.imread("resim.jpg")

if img is None:
    print("Görüntü bulunamadı!")
    exit()

# 1. Gri Tonlama
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)

# 2. Kenar Tespiti
edges = cv2.Canny(gray, 100, 200)

# 3. Yüz Tespiti
face_cascade = cv2.CascadeClassifier(cv2.data.haarcascades + "haarcascade_frontalface_default.xml")
faces = face_cascade.detectMultiScale(gray, 1.3, 5)

for (x, y, w, h) in faces:
    cv2.rectangle(img, (x, y), (x + w, y + h), (255, 0, 0), 2)

# Gösterim
cv2.imshow("Orijinal ve Yuz Tespiti", img)
cv2.imshow("Gri Tonlama", gray)
cv2.imshow("Kenar Tespiti", edges)

cv2.waitKey(0)
cv2.destroyAllWindows()
____
8. Uygulama: Canlı Kamera ile Yüz Tespiti

import cv2

# Kamerayı başlat (0 varsayılan kamera, açılmazsa 1 deneyin)
cap = cv2.VideoCapture(0)
face_cascade = cv2.CascadeClassifier(cv2.data.haarcascades + "haarcascade_frontalface_default.xml")

while True:
    ret, frame = cap.read()
    if not ret:
        break

    gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
    faces = face_cascade.detectMultiScale(gray, 1.3, 5)

    for (x, y, w, h) in faces:
        cv2.rectangle(frame, (x, y), (x + w, y + h), (255, 0, 0), 2)

    cv2.imshow("Canli Yuz Tespiti", frame)

    # 'q' tuşuna basılırsa döngüden çık
    if cv2.waitKey(1) & 0xFF == ord('q'):
        break

cap.release()
cv2.destroyAllWindows()