Merhaba,

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))

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)

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()

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()