🏎️ FaceRacer

Yüz Kontrollü 3D Yarış Oyunu

Gelişmiş yüz takibi teknolojisi ile kafa hareketleriyle oynanan yenilikçi oyun deneyimi. Kafanızı sağa/sola çevirin, hız kazanın ve yarışın!

🎮 Oyunu Oyna 📖 Daha Fazla Bilgi

FaceRacer Hakkında

FaceRacer, gelişmiş yüz takibi teknolojisi kullanılarak geliştirilmiş yenilikçi bir 3D yarış oyunudur. Kamera aracılığıyla yüzünüzü takip ederek, kafa hareketleriyle arabanızı kontrol edebilirsiniz. Klavye veya mouse kullanmadan, sadece yüz hareketleriyle oynanan bu oyun, yapay zeka ve oyun geliştirme teknolojilerinin mükemmel bir örneğidir.

🎯

Yüz Takibi

🏎️

3D Yarış

🤖

Yapay Zeka

Özellikler

🔄 Kafa sağa/sola → Dönüş kontrolü
⬆️⬇️ Kafa yukarı/aşağı → Hız kontrolü
😉 Göz kırpma → Nitro turbo
🏆 Leaderboard sistemi
🎨 Farklı araba seçenekleri
📱 Mobil uyumlu

Hakkımda

Python ile web scraping, veri işleme ve otomasyon projeleri geliştiriyorum. Teknolojiye olan tutkumla sürekli yeni şeyler öğreniyor ve pratik projelerle bilgilerimi geliştiriyorum. GitHub üzerinde açık kaynak projeler paylaşarak topluluğa katkıda bulunmayı hedefliyorum.

10+

Proje

Python

Uzmanlık

Web Scraping

Özel İlgi

Teknik Yetenekler

Programlama Dilleri

Python JavaScript HTML/CSS SQL

Python Kütüphaneleri

BeautifulSoup Selenium Pandas Requests Flask

Araçlar & Platformlar

Git GitHub VS Code Docker

Python Kod Demoları

Uzmanlık alanımdaki yeteneklerimi gösteren etkileyici kod örnekleri

İleri Düzey Web Scraping

Anti-bot sistemlerini aşan, rate-limiting ve proxy rotasyonu kullanan profesyonel scraper

import asyncio
import aiohttp
from bs4 import BeautifulSoup
from fake_useragent import UserAgent
import random

class AdvancedScraper:
    def __init__(self):
        self.ua = UserAgent()
        self.proxies = [
            'http://proxy1.com:8080',
            'http://proxy2.com:8080',
            'http://proxy3.com:8080'
        ]
        self.rate_limit = 2  # requests per second
        
    async def fetch_page(self, session, url):
        headers = {'User-Agent': self.ua.random}
        proxy = random.choice(self.proxies)
        
        async with session.get(url, headers=headers, 
                               proxy=proxy, timeout=30) as response:
            if response.status == 200:
                return await response.text()
            return None
    
    async def scrape_multiple(self, urls):
        async with aiohttp.ClientSession() as session:
            tasks = []
            for url in urls:
                task = self.fetch_page(session, url)
                tasks.append(task)
                await asyncio.sleep(1 / self.rate_limit)
            
            results = await asyncio.gather(*tasks)
            return [r for r in results if r]

# Kullanım
scraper = AdvancedScraper()
urls = ['https://example1.com', 'https://example2.com']
data = asyncio.run(scraper.scrape_multiple(urls))

Async/Await Anti-Bot Proxy Rotasyon

Veri İşleme Pipeline

Büyük veri setlerini otomatik temizleyen, dönüştüren ve analiz eden pipeline

import pandas as pd
import numpy as np
from typing import List, Dict
import re

class DataPipeline:
    def __init__(self):
        self.cleaners = [
            self.remove_duplicates,
            self.handle_missing_values,
            self.normalize_text,
            self.detect_outliers
        ]
    
    def remove_duplicates(self, df: pd.DataFrame) -> pd.DataFrame:
        """Tekrarlayan kayıtları kaldır"""
        return df.drop_duplicates()
    
    def handle_missing_values(self, df: pd.DataFrame) -> pd.DataFrame:
        """Eksik değerleri doldur"""
        numeric_cols = df.select_dtypes(include=[np.number]).columns
        df[numeric_cols] = df[numeric_cols].fillna(df[numeric_cols].median())
        return df
    
    def normalize_text(self, df: pd.DataFrame) -> pd.DataFrame:
        """Metinleri normalize et"""
        text_cols = df.select_dtypes(include=['object']).columns
        for col in text_cols:
            df[col] = df[col].str.lower().str.strip()
            df[col] = df[col].apply(lambda x: re.sub(r'[^\w\s]', '', str(x)))
        return df
    
    def detect_outliers(self, df: pd.DataFrame) -> pd.DataFrame:
        """Aykırı değerleri tespit et"""
        numeric_cols = df.select_dtypes(include=[np.number]).columns
        for col in numeric_cols:
            Q1 = df[col].quantile(0.25)
            Q3 = df[col].quantile(0.75)
            IQR = Q3 - Q1
            df = df[~((df[col] < (Q1 - 1.5 * IQR)) | 
                     (df[col] > (Q3 + 1.5 * IQR)))]
        return df
    
    def process(self, raw_data: List[Dict]) -> pd.DataFrame:
        """Veriyi pipeline'dan geçir"""
        df = pd.DataFrame(raw_data)
        
        for cleaner in self.cleaners:
            df = cleaner(df)
            print(f"✓ {cleaner.__name__} tamamlandı")
        
        return df

# Kullanım
pipeline = DataPipeline()
raw_data = [{'name': '  Test  ', 'value': 100}, 
            {'name': 'test', 'value': 105}]
clean_data = pipeline.process(raw_data)

Pandas Auto-Clean Analysis

Akıllı Veri Agent

Kendiliğinden öğrenen ve strateji geliştiren otonom veri toplama agent

import json
from datetime import datetime
from typing import Dict, List
import random

class DataAgent:
    def __init__(self, name: str):
        self.name = name
        self.memory = {}
        self.success_rate = 0.0
        self.strategies = {
            'aggressive': 0.3,
            'balanced': 0.5,
            'conservative': 0.2
        }
        self.learning_rate = 0.1
    
    def learn(self, success: bool, strategy: str):
        """Başarıya göre öğren"""
        if success:
            self.strategies[strategy] += self.learning_rate
            self.success_rate = min(1.0, self.success_rate + 0.05)
        else:
            self.strategies[strategy] -= self.learning_rate
            self.success_rate = max(0.0, self.success_rate - 0.02)
        
        # Normalize stratejiler
        total = sum(self.strategies.values())
        for key in self.strategies:
            self.strategies[key] /= total
    
    def select_strategy(self) -> str:
        """En iyi stratejiyi seç"""
        return random.choices(
            list(self.strategies.keys()),
            weights=list(self.strategies.values())
        )[0]
    
    def execute_task(self, task: Dict) -> Dict:
        """Görevi çalıştır"""
        strategy = self.select_strategy()
        
        # Simüle edilmiş görev
        success_chance = {
            'aggressive': 0.4,
            'balanced': 0.7,
            'conservative': 0.9
        }[strategy]
        
        success = random.random() < success_chance
        self.learn(success, strategy)
        
        return {
            'agent': self.name,
            'strategy': strategy,
            'success': success,
            'success_rate': self.success_rate,
            'timestamp': datetime.now().isoformat()
        }
    
    def save_memory(self):
        """Hafızayı kaydet"""
        with open(f'{self.name}_memory.json', 'w') as f:
            json.dump({
                'strategies': self.strategies,
                'success_rate': self.success_rate
            }, f)

# Kullanım
agent = DataAgent("AlphaBot")
for _ in range(10):
    result = agent.execute_task({'type': 'scrape'})
    print(f"Strategy: {result['strategy']}, Success: {result['success']}")
agent.save_memory()

Machine Learning Self-Improving Strategy

Snake Oyunu

Pygame ile geliştirilmiş klasik yılan oyunu - OOP, event handling ve oyun döngüsü

import pygame
import random
import sys

class SnakeGame:
    def __init__(self):
        pygame.init()
        self.width = 800
        self.height = 600
        self.screen = pygame.display.set_mode((self.width, self.height))
        pygame.display.set_caption("Python Snake Game")
        self.clock = pygame.time.Clock()
        
        # Renkler
        self.BLACK = (0, 0, 0)
        self.WHITE = (255, 255, 255)
        self.GREEN = (0, 255, 0)
        self.RED = (255, 0, 0)
        self.BLUE = (0, 0, 255)
        
        # Oyun ayarları
        self.block_size = 20
        self.snake_speed = 15
        
        # Yılan başlangıç
        self.snake = []
        self.snake_length = 1
        self.x1 = self.width // 2
        self.y1 = self.height // 2
        self.x1_change = 0
        self.y1_change = 0
        
        # Yem
        self.food_x = round(random.randrange(0, self.width - self.block_size) / self.block_size) * self.block_size
        self.food_y = round(random.randrange(0, self.height - self.block_size) / self.block_size) * self.block_size
        
        # Skor
        self.score = 0
        
    def handle_events(self):
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                return False
            if event.type == pygame.KEYDOWN:
                if event.key == pygame.K_LEFT and self.x1_change == 0:
                    self.x1_change = -self.block_size
                    self.y1_change = 0
                elif event.key == pygame.K_RIGHT and self.x1_change == 0:
                    self.x1_change = self.block_size
                    self.y1_change = 0
                elif event.key == pygame.K_UP and self.y1_change == 0:
                    self.y1_change = -self.block_size
                    self.x1_change = 0
                elif event.key == pygame.K_DOWN and self.y1_change == 0:
                    self.y1_change = self.block_size
                    self.x1_change = 0
        return True
    
    def update(self):
        self.x1 += self.x1_change
        self.y1 += self.y1_change
        
        # Yılanın yeni başını ekle
        self.snake.append([self.x1, self.y1])
        
        # Yılanı istenen uzunlukta tut
        if len(self.snake) > self.snake_length:
            del self.snake[0]
        
        # Yem yeme kontrolü
        if self.x1 == self.food_x and self.y1 == self.food_y:
            self.food_x = round(random.randrange(0, self.width - self.block_size) / self.block_size) * self.block_size
            self.food_y = round(random.randrange(0, self.height - self.block_size) / self.block_size) * self.block_size
            self.snake_length += 1
            self.score += 10
        
        # Duvar çarpışması
        if self.x1 >= self.width or self.x1 < 0 or self.y1 >= self.height or self.y1 < 0:
            return False
        
        # Kendine çarpışma
        for segment in self.snake[:-1]:
            if segment == [self.x1, self.y1]:
                return False
        
        return True
    
    def draw(self):
        self.screen.fill(self.BLACK)
        
        # Yılanı çiz
        for segment in self.snake:
            pygame.draw.rect(self.screen, self.GREEN, [segment[0], segment[1], self.block_size, self.block_size])
        
        # Yemi çiz
        pygame.draw.rect(self.screen, self.RED, [self.food_x, self.food_y, self.block_size, self.block_size])
        
        # Skoru göster
        font = pygame.font.SysFont('Arial', 30)
        score_text = font.render(f'Skor: {self.score}', True, self.WHITE)
        self.screen.blit(score_text, [10, 10])
        
        pygame.display.update()
    
    def run(self):
        running = True
        while running:
            running = self.handle_events()
            if not running:
                break
            
            running = self.update()
            if not running:
                break
            
            self.draw()
            self.clock.tick(self.snake_speed)
        
        # Game Over ekranı
        font = pygame.font.SysFont('Arial', 50)
        game_over_text = font.render('Oyun Bitti!', True, self.RED)
        final_score_text = font.render(f'Final Skor: {self.score}', True, self.WHITE)
        
        self.screen.blit(game_over_text, [self.width // 2 - 150, self.height // 2 - 50])
        self.screen.blit(final_score_text, [self.width // 2 - 150, self.height // 2 + 10])
        pygame.display.update()
        
        pygame.time.wait(3000)
        pygame.quit()
        sys.exit()

# Oyunu başlat
if __name__ == "__main__":
    game = SnakeGame()
    game.run()

Pygame OOP Event Loop

Projelerim

Web Scraping Agent

Çoklu web sitesinden veri çekme ve işleme otomasyonu. Agent tabanlı yapı ile esnek veri toplama.

GitHub

Python BeautifulSoup Selenium

Fiyat Takip Botu

Sahibinden ve benzeri platformlardan ürün fiyatlarını takip eden ve değişimleri raporlayan sistem.

GitHub

Python Pandas API

Medya İndirici

Çeşitli platformlardan video ve medya içerikleri indirme aracı. Batch işleme desteği.

GitHub

Python yt-dlp FFmpeg

Bulk URL Extractor

Büyük metin dosyalarından URL'leri çıkaran ve kategorize eden otomasyon aracı.

GitHub

Python Regex Pandas

Splitwise Entegrasyonu

Splitwise API ile masrafları takip eden ve raporlayan kişisel finans aracı.

GitHub

Python REST API JSON

WebSift

Web içeriklerini analiz eden ve filtreleyen akıllı içerik işleme aracı.

GitHub

Python NLP ML

FaceRacer

Yüz takibi ve kafa hareketleriyle oynanan 3D araba yarışı oyunu. Engelli bireyler için erişilebilir oyun deneyimi.

Oyna

Three.js MediaPipe JavaScript

İletişim

Email

info@hakancetin.com

Web Sitesi

https://hakancetin.com

GitHub

github.com/hakancet27-dotcom