Типы данных в Python

# Демонстрация концепции "всё — объект"
x = 42
print(type(x))  # <class 'int'>
print(id(x))    # уникальный идентификатор объекта
y = "Hello"
print(type(y))  # <class 'str'>
 
# Даже функции — объекты
def say_hi():
    return "Hi there!"
 
print(type(say_hi))  # <class 'function'>

# Большие числа — не проблема для Python
factorial_100 = 93326215443944152681699238856266700490715968264381621468592963895217599993229915608941463976156518286253697920827223758251185210916864000000000000000000000000
print(factorial_100 + 1)  # Python без проблем обрабатывает огромные числа

# Классическая проблема с плавающей точкой
result = 0.1 + 0.2
print(result)  # 0.30000000000000004
print(result == 0.3)  # False, хотя математически это должно быть True

# Работа с комплексными числами
z1 = 2 + 3j
z2 = complex(1, 2)  # 1 + 2j
print(z1 * z2)  # (-4+7j)

# Строки и их методы
greeting = "Привет, мир!"
print(len(greeting))  # 12
print(greeting.upper())  # ПРИВЕТ, МИР!
print(greeting[0:6])  # Привет

text = "  Python — это здорово!  "
print(text.strip())  # "Python — это здорово!"
print(text.replace("здорово", "потрясающе"))  # "  Python — это потрясающе!  "
print("python" in text.lower())  # True

print(isinstance(True, int))  # True
print(True + True)  # 2
print(True * 8)  # 8

# Подсчёт соответствий условию
values = [1, 2, 3, 4, 5, 6]
count = sum(val % 2 == 0 for val in values)  # Сколько чётных чисел?
print(count)  # 3

def find_in_list(item, my_list):
    try:
        index = my_list.index(item)
        return index
    except ValueError:
        return None
 
result = find_in_list(42, [1, 2, 3])
if result is None:
    print("Элемент не найден")

# Создание объекта bytes
sample = bytes([65, 66, 67, 68])
print(sample)  # b'ABCD'
print(sample[0])  # 65

# Работа с bytearray
mutable_bytes = bytearray([65, 66, 67, 68])
mutable_bytes[0] = 90  # Заменяем 'A' (65) на 'Z' (90)
print(mutable_bytes)  # bytearray(b'ZBCD')

# Использование memoryview для эффективной работы с данными
large_bytes = bytearray(10 * 1024 * 1024)  # 10 МБ данных
view = memoryview(large_bytes)
# Можно изменять данные через view без копирования
view[0] = 42
print(large_bytes[0])  # 42

import sys
 
# Получение количества ссылок на объект
a = [1, 2, 3]
b = a  # Теперь на список ссылаются две переменные
print(sys.getrefcount(a) - 1)  # 2 (минус 1, т.к. сама функция создаёт временную ссылку)

from decimal import Decimal, getcontext
 
# Установка точности
getcontext().prec = 28
 
# Проблема с float
print(0.1 + 0.2)  # 0.30000000000000004
 
# Решение с Decimal
print(Decimal('0.1') + Decimal('0.2'))  # 0.3

a = 42
b = 42
print(a is b)  # True - это один и тот же объект в памяти
 
c = 1000
d = 1000
print(c is d)  # False - разные объекты

# Работа с Unicode в Python 3
hello_world = "Привет, мир!"
print(len(hello_world))  # 13 символов, а не байтов
 
# Получение кода символа
print(ord('A'))  # 65
print(ord('emoji'))  # 128075
 
# Преобразование кода в символ
print(chr(65))  # 'A'
print(chr(128075))  # emoji

# Нормализация Unicode
import unicodedata
 
s1 = "café"  # 'é' как один символ
s2 = "cafe\u0301"  # 'e' + акцент
print(s1 == s2)  # False
print(unicodedata.normalize('NFC', s1) == unicodedata.normalize('NFC', s2))  # True

# Преобразование строки в байты
text = "Python"
binary = text.encode('utf-8')
print(binary)  # b'Python'
 
# Обратное преобразование
decoded = binary.decode('utf-8')
print(decoded)  # 'Python'

# Эффективная работа с большими данными
large_data = bytearray(10 * 1024 * 1024)  # 10 МБ данных
view = memoryview(large_data)
view[0:5] = b'hello'  # Изменяем только нужный участок без копирования всего массива

# Создаем циклическую ссылку
a = []
b = [a]
a.append(b)  # Теперь a и b ссылаются друг на друга
 
# Удаляем внешние ссылки
del a
del b
# Объекты остаются в памяти, пока сборщик мусора их не обнаружит

# Типичное использование списка
tasks = ["Написать код", "Протестировать", "Задеплоить"]
tasks.append("Отдохнуть")
tasks[0] = "Написать лучший код"
print(tasks)  # ['Написать лучший код', 'Протестировать', 'Задеплоить', 'Отдохнуть']

# Кортежи как структурированные данные
point = (4, 5)
person = ("Иван", "Петров", 35)
x, y = point  # Распаковка кортежа
name, surname, age = person

import timeit
 
# Сравнение производительности
list_time = timeit.timeit("x = [1, 2, 3, 4, 5]", number=1000000)
tuple_time = timeit.timeit("x = (1, 2, 3, 4, 5)", number=1000000)
print(f"Время создания списка: {list_time}")
print(f"Время создания кортежа: {tuple_time}")
print(f"Кортежи быстрее на {(list_time - tuple_time) / list_time * 100:.2f}%")

# Мощь словарей
user = {
    "username": "python_lover",
    "email": "py@example.com",
    "role": "developer",
    "skills": ["Python", "SQL", "Docker"]
}
print(user["role"])  # developer
user["location"] = "Remote"  # Добавление нового поля

# Порядок элементов в современных словарях сохраняется
steps = {}
steps[1] = "Понять"
steps[2] = "Спроектировать"
steps[3] = "Разработать"
steps[4] = "Тестировать"
 
for step_num, action in steps.items():
    print(f"Шаг {step_num}: {action}")
# Выведет шаги в порядке добавления: 1, 2, 3, 4

# Использование множеств для работы с уникальными значениями
developers = {"Алиса", "Боб", "Чарли"}
testers = {"Боб", "Дейв", "Ева"}
 
# Кто работает и разработчиком, и тестировщиком?
print(developers & testers)  # {'Боб'}
 
# Все участники команды
print(developers | testers)  # {'Алиса', 'Боб', 'Чарли', 'Дейв', 'Ева'}
 
# Только разработчики (не тестировщики)
print(developers - testers)  # {'Алиса', 'Чарли'}

# Создание frozenset
immutable_tags = frozenset(["python", "programming", "development"])
# immutable_tags.add("code")  # Вызовет AttributeError

# Использование frozenset как ключа
team_skills = {
frozenset(["python", "django", "postgres"]): ["Алиса", "Боб"],
frozenset(["javascript", "react", "node"]): ["Чарли", "Дейв"]
}
 
# Поиск команды по набору навыков
required_skills = frozenset(["python", "django", "postgres"])
print(f"Эксперты: {team_skills[required_skills]}")  # Эксперты: ['Алиса', 'Боб']

import time
 
# Демонстрация разницы в производительности
def performance_test(collection_size):
test_list = list(range(collection_size))
test_set = set(test_list)
 
element = collection_size - 1  # Ищем последний элемент (худший случай для списка)
    
# Замеряем время поиска в списке
start = time.time()
result_list = element in test_list
list_time = time.time() - start
    
# Замеряем время поиска в множестве
start = time.time()
result_set = element in test_set
set_time = time.time() - start
    
print(f"Размер коллекции: {collection_size}")
print(f"Время поиска в списке: {list_time:.7f} сек")
print(f"Время поиска в множестве: {set_time:.7f} сек")
print(f"Множество быстрее в {list_time/set_time:.0f} раз\n")
 
# Тестируем на разных размерах
for size in [1000, 10000, 100000]:
performance_test(size)

def fibonacci(n):
a, b = 0, 1
for _ in range(n):
yield a
a, b = b, a + b
 
# Использование генератора
for num in fibonacci(10):
print(num, end=" ")  # 0 1 1 2 3 5 8 13 21 34

def process_large_log(filename):
with open(filename, 'r') as file:
for line in file:  # file — итератор, читающий файл построчно
if "ERROR" in line:
yield line
 
# Обработка логов без загрузки всего файла в память
for error_line in process_large_log("huge_log.txt"):
print(f"Найдена ошибка: {error_line.strip()}")

# Генераторное выражение
squares = (x[B]2 for x in range(10))
print(next(squares))  # 0
print(next(squares))  # 1
 
# Эквивалентная генераторная функция
def squares_func(n):
for x in range(n):
yield x[/B]2

# Списковое включение для создания списка квадратов
squares = [x**2 for x in range(10)]
print(squares)  # [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
 
# С условным фильтром
even_squares = [x**2 for x in range(10) if x % 2 == 0]
print(even_squares)  # [0, 4, 16, 36, 64]

# Словарное включение
word = "hello"
char_index = {char: index for index, char in enumerate(word)}
print(char_index)  # {'h': 0, 'e': 1, 'l': 3, 'o': 4}
 
# Множественное включение
vowels = {char for char in "hello world" if char in "aeiou"}
print(vowels)  # {'e', 'o'}

# Подсчёт запросов по IP-адресам
def count_ips(log_file):
with open(log_file) as f:
ip_addresses = (line.split()[0] for line in f if line.strip())
return {ip: sum(1 for _ in ip_addresses if _ == ip) for ip in set(ip_addresses)}

def count_ips(log_file):
with open(log_file) as f:
ip_addresses = [line.split()[0] for line in f if line.strip()]
return {ip: ip_addresses.count(ip) for ip in set(ip_addresses)}

from collections import Counter
 
def count_ips(log_file):
with open(log_file) as f:
ip_addresses = [line.split()[0] for line in f if line.strip()]
return Counter(ip_addresses)

from collections import defaultdict
 
# Группировка слов по первой букве
words = ["apple", "banana", "avocado", "cherry", "blueberry"]
 
# Традиционный способ
groups_traditional = {}
for word in words:
first_letter = word[0]
if first_letter not in groups_traditional:
groups_traditional[first_letter] = []
groups_traditional[first_letter].append(word)
 
# С defaultdict
groups = defaultdict(list)
for word in words:
groups[word[0]].append(word)
 
print(dict(groups))  # {'a': ['apple', 'avocado'], 'b': ['banana', 'blueberry'], 'c': ['cherry']}

from collections import namedtuple
 
# Создание типа Point
Point = namedtuple('Point', ['x', 'y'])
 
p = Point(4, 5)
print(p.x, p.y)  # 4 5
print(p[0], p[1])  # 4 5
 
# Использование распаковки
x, y = p
print(f"Координаты: ({x}, {y})")  # Координаты: (4, 5)

# До применения namedtuple
weather_data = [
(2023, 1, 15, -5, 760, 85),
(2023, 1, 16, -3, 758, 80),
# ...
]
for record in weather_data:
if record[3] < 0 and record[5] > 80:
print(f"Мороз и высокая влажность: {record[2]}.{record[1]}.{record[0]}")
 
# После - гораздо понятнее!
WeatherRecord = namedtuple('WeatherRecord', 'year month day temp pressure humidity')
weather_data = [
WeatherRecord(2023, 1, 15, -5, 760, 85),
WeatherRecord(2023, 1, 16, -3, 758, 80),
# ...
]
for record in weather_data:
if record.temp < 0 and record.humidity > 80:
print(f"Мороз и высокая влажность: {record.day}.{record.month}.{record.year}")

from collections import deque
 
# Эффективная очередь
queue = deque(["Задача 1", "Задача 2", "Задача 3"])
queue.append("Задача 4")  # Добавление в конец
first_task = queue.popleft()  # Удаление с начала - O(1)
print(first_task)  # Задача 1
print(queue)  # deque(['Задача 2', 'Задача 3', 'Задача 4'])
 
# Эффективный стек
stack = deque()
stack.append("Уровень 1")
stack.append("Уровень 2")
top = stack.pop()  # Удаление с конца - O(1)
print(top)  # Уровень 2

# Простой LRU-кэш
class SimpleCache:
def __init__(self, maxsize=100):
self.cache = deque(maxlen=maxsize)
self._cache_dict = {}
    
def get(self, key):
if key not in self._cache_dict:
return None
# Обновляем порядок - перемещаем элемент в конец
self.cache.remove(key)
self.cache.append(key)
return self._cache_dict[key]
    
def set(self, key, value):
if key in self._cache_dict:
self.cache.remove(key)
self.cache.append(key)
self._cache_dict[key] = value
return
        
# Если кэш полон, самый старый элемент будет автоматически удалён
self.cache.append(key)
self._cache_dict[key] = value

# В статически типизированном языке (например, Java)
# String name = "Python";
[H2]int version = 3;[/H2]
 
# В Python всё проще
name = "Python"
version = 3
version = "3.9"  # Можно изменить тип переменной на лету

# Список с элементами разных типов
mixed_data = [42, "Hello", 3.14, [1, 2, 3]]

# Пример "утиной типизации"
def calculate_area(shape):
    return shape.area()  # Нас не волнует тип shape, главное — наличие метода area()
 
class Circle:
    def __init__(self, radius):
        self.radius = radius
        
    def area(self):
        return 3.14 * self.radius ** 2
 
class Square:
    def __init__(self, side):
        self.side = side
        
    def area(self):
        return self.side ** 2
 
# Обе фигуры работают с нашей функцией
print(calculate_area(Circle(5)))  # 78.5
print(calculate_area(Square(5)))  # 25

print(10 + 5)       # 15 (сложение чисел)
print("10" + "5")   # "105" (конкатенация строк)
print([1, 2] + [3]) # [1, 2, 3] (конкатенация списков)

def calculate_discount(price: float, discount_percent: float) -> float:
    return price * (1 - discount_percent / 100)
 
result = calculate_discount(100, "50")  # Код выполнится, но статический анализатор укажет на ошибку

# Исследование объекта во время выполнения
obj = [1, 2, 3]
 
# Получение типа объекта
print(type(obj))  # <class 'list'>
 
# Проверка принадлежности к типу
print(isinstance(obj, list))  # True
 
# Получение списка атрибутов и методов
print(dir(obj))  # ['__add__', '__class__', ..., 'append', 'clear', ...]
 
# Получение документации
print(help(obj.append))

def process_data(data):
    if hasattr(data, 'read') and callable(data.read):
        # Это похоже на файлоподобный объект
        return process_file_like_object(data)
    elif hasattr(data, '__iter__') and not isinstance(data, (str, bytes, dict)):
        # Это итерируемый объект (но не строка, байты или словарь)
        return process_iterable(data)
    elif hasattr(data, 'items') and callable(data.items):
        # Это словареподобный объект
        return process_dict_like(data)
    else:
        # Обработка по умолчанию
        return process_default(data)

def describe_data(data):
    match data:
        case int() | float() as num if num > 0:
            return f"Положительное число: {num}"
        case str() as text if len(text) > 0:
            return f"Непустая строка длиной {len(text)}"
        case [] | ():
            return "Пустая последовательность"
        case [first, *rest]:
            return f"Последовательность, начинающаяся с {first}, всего {len(rest) + 1} элементов"
        case {"name": name, "age": age}:
            return f"Словарь с информацией о человеке: {name}, {age} лет"
        case _:
            return "Неопознанный тип данных"

from typing import List, Dict, Optional, Union
 
def process_users(users: List[Dict[str, Union[str, int]]]) -> Optional[str]:
    """Обработка списка пользователей.
    
    Args:
        users: Список словарей с данными пользователей
        
    Returns:
        Строка с результатом или None в случае ошибки
    """
    if not users:
        return None
    
    result = []
    for user in users:
        name = user.get("name", "Unknown")
        age = user.get("age", 0)
        result.append(f"{name}: {age}")
    
    return ", ".join(result)

# mypy.ini
[mypy]
python_version = 3.9
warn_return_any = True
 
[mypy.plugins.numpy.*]
ignore_missing_imports = True

from dataclasses import dataclass
from typing import List, Optional
 
@dataclass
class User:
    name: str
    email: str
    age: int = 0
    is_active: bool = True
    tags: List[str] = None
    
    def __post_init__(self):
        if self.tags is None:
            self.tags = []
 
# Создание объекта
user = User("Алексей", "alex@example.com")
print(user)  # User(name='Алексей', email='alex@example.com', age=0, is_active=True, tags=[])

from typing import TypeVar, List, Callable
 
T = TypeVar('T')  # Определяем типовую переменную
 
def filter_list(items: List[T], predicate: Callable[[T], bool]) -> List[T]:
    return [item for item in items if predicate(item)]
 
# Использование с разными типами
numbers = [1, 2, 3, 4, 5]
filtered_nums = filter_list(numbers, lambda x: x % 2 == 0)
print(filtered_nums)  # [2, 4]
 
names = ["Alice", "Bob", "Charlie", "David"]
filtered_names = filter_list(names, lambda x: len(x) > 4)
print(filtered_names)  # ["Alice", "Charlie", "David"]

from typing import TypeVar, List, Union
 
# T может быть только str или int
T = TypeVar('T', str, int)
 
def first_element(items: List[T]) -> Union[T, None]:
    return items[0] if items else None
 
# Это работает
print(first_element([1, 2, 3]))  # 1
print(first_element(["a", "b", "c"]))  # "a"
 
# А это вызовет ошибку при проверке типов
# print(first_element([1.0, 2.0, 3.0]))  # Ошибка: float не соответствует ограничениям T

from typing import Protocol, List
 
class Drawable(Protocol):
    def draw(self) -> None: ...
 
class Circle:
    def __init__(self, radius: float):
        self.radius = radius
        
    def draw(self) -> None:
        print(f"Drawing circle with radius {self.radius}")
 
class Square:
    def __init__(self, side: float):
        self.side = side
        
    def draw(self) -> None:
        print(f"Drawing square with side {self.side}")
 
def draw_all(items: List[Drawable]) -> None:
    for item in items:
        item.draw()
 
# Оба класса соответствуют протоколу Drawable
shapes = [Circle(5.0), Square(4.0)]
draw_all(shapes)

from typing import TypedDict, List
 
class MovieDict(TypedDict):
    title: str
    year: int
    director: str
    cast: List[str]
 
# Создание объекта, соответствующего типу
movie: MovieDict = {
    "title": "Матрица",
    "year": 1999,
    "director": "Вачовски",
    "cast": ["Киану Ривз", "Лоуренс Фишбёрн"]
}

from typing import Callable, List, TypeVar
 
T = TypeVar('T')
R = TypeVar('R')
 
def map_list(items: List[T], mapper: Callable[[T], R]) -> List[R]:
    return [mapper(item) for item in items]
 
# Использование
numbers = [1, 2, 3, 4, 5]
doubled = map_list(numbers, lambda x: x * 2)
names = map_list(numbers, lambda x: f"Item {x}")

from typing import Literal
 
def align_text(text: str, alignment: Literal["left", "center", "right"]) -> str:
    if alignment == "left":
        return text.ljust(20)
    elif alignment == "center":
        return text.center(20)
    else:  # alignment == "right"
        return text.rjust(20)
 
# Это правильно
print(align_text("Python", "center"))
 
# А это вызовет ошибку при проверке типов
# print(align_text("Python", "top"))

from typing import NewType, Dict
 
UserId = NewType('UserId', int)
ProductId = NewType('ProductId', int)
 
def get_user_products(user_id: UserId) -> Dict[ProductId, str]:
    # Реализация
    return {}
 
# Несмотря на то, что оба типа основаны на int,
# они семантически различны
user_id = UserId(42)
product_id = ProductId(123)
 
# Это вызовет ошибку при проверке типов
# get_user_products(product_id)

from typing import Protocol, List
 
class Renderable(Protocol):
    def render(self) -> str: ...
 
class HTMLElement:
    def render(self) -> str:
        return "<div>Some content</div>"
 
class JSONData:
    def render(self) -> str:
        return '{"data": "Some content"}'
 
def render_all(items: List[Renderable]) -> str:
    return "\n".join(item.render() for item in items)
 
# Оба класса подходят, хотя ни один не наследует Renderable явно
elements = [HTMLElement(), JSONData()]
result = render_all(elements)

class Sized(Protocol):
    def __len__(self) -> int: ...
 
class Container(Protocol):
    def __contains__(self, item: object) -> bool: ...
 
class Collection(Sized, Container, Protocol):
    def __iter__(self): ...

class DataSource(Protocol):
    def connect(self) -> bool: ...
    def fetch_data(self, query: str) -> List[Dict[str, any]]: ...
    def close(self) -> None: ...

from typing import Protocol, runtime_checkable
 
@runtime_checkable
class Closable(Protocol):
    def close(self) -> None: ...
 
class File:
    def close(self) -> None:
        print("Closing file")
 
class Database:
    def close(self) -> None:
        print("Closing database connection")
 
class Service:
    def stop(self) -> None:
        print("Stopping service")
 
# Проверка во время выполнения
for obj in [File(), Database(), Service()]:
    if isinstance(obj, Closable):
        obj.close()
    else:
        print(f"{obj.__class__.__name__} is not closable")

from typing import Protocol, TypeVar, Generic, List
 
T = TypeVar('T')
 
class Repository(Protocol[T]):
    def get_all(self) -> List[T]: ...
    def save(self, item: T) -> None: ...
    def find_by_id(self, id: int) -> T: ...
 
# Использование с конкретным типом
class UserRepository:
    def get_all(self) -> List[User]:
        # Реализация
        ...
    
    def save(self, user: User) -> None:
        # Реализация
        ...
    
    def find_by_id(self, id: int) -> User:
        # Реализация
        ...
 
def process_entities(repo: Repository[User]):
    users = repo.get_all()
    # Обработка данных

from dataclasses import dataclass, field
from typing import Dict, List, Set, Optional, Protocol, Tuple, Iterator
from datetime import datetime
from collections import Counter, defaultdict
from enum import Enum
import re
from pathlib import Path
 
# Определяем основные типы данных
class LogLevel(Enum):
    INFO = "INFO"
    WARNING = "WARNING"
    ERROR = "ERROR"
 
@dataclass
class LogEntry:
    timestamp: datetime
    ip_address: str
    level: LogLevel
    path: str
    status_code: int
    response_time: float
    user_agent: Optional[str] = None
    tags: Set[str] = field(default_factory=set)
 
# Протокол для источников данных
class DataSource(Protocol):
    def get_entries(self) -> Iterator[LogEntry]: ...
 
# Реализация источника данных из файла
class FileLogSource:
    def __init__(self, log_path: Path):
        self.log_path = log_path
        self._pattern = re.compile(
            r'(\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}) (\d+\.\d+\.\d+\.\d+) '
            r'(\w+) (\S+) (\d+) (\d+\.\d+)(?: "([^"]*)")?'
        )
    
    def get_entries(self) -> Iterator[LogEntry]:
        with open(self.log_path, 'r') as file:
            for line in file:
                match = self._pattern.match(line.strip())
                if match:
                    timestamp_str, ip, level_str, path, status, resp_time, user_agent = match.groups()
                    try:
                        yield LogEntry(
                            timestamp=datetime.strptime(timestamp_str, '%Y-%m-%d %H:%M:%S'),
                            ip_address=ip,
                            level=LogLevel(level_str),
                            path=path,
                            status_code=int(status),
                            response_time=float(resp_time),
                            user_agent=user_agent
                        )
                    except ValueError:
                        # Пропускаем невалидные записи
                        continue
 
# Анализатор логов
class LogAnalyzer:
    def __init__(self, source: DataSource):
        self.source = source
        self.entries: List[LogEntry] = []
        self._load_data()
    
    def _load_data(self) -> None:
        self.entries = list(self.source.get_entries())
    
    def get_top_ips(self, limit: int = 10) -> List[Tuple[str, int]]:
        """Возвращает самые активные IP-адреса."""
        counter = Counter(entry.ip_address for entry in self.entries)
        return counter.most_common(limit)
    
    def get_path_stats(self) -> Dict[str, Dict[str, float]]:
        """Анализ статистики по путям."""
        result: Dict[str, Dict[str, float]] = defaultdict(lambda: {"count": 0, "avg_time": 0.0})
        
        path_times: Dict[str, List[float]] = defaultdict(list)
        
        for entry in self.entries:
            path_times[entry.path].append(entry.response_time)
        
        for path, times in path_times.items():
            result[path] = {
                "count": len(times),
                "avg_time": sum(times) / len(times)
            }
        
        return dict(result)
    
    def find_potential_attacks(self) -> Set[str]:
        """Поиск потенциальных атак (много ошибок от одного IP)."""
        suspicious_ips: Set[str] = set()
        errors_by_ip: Dict[str, int] = defaultdict(int)
        
        for entry in self.entries:
            if entry.level == LogLevel.ERROR and entry.status_code >= 400:
                errors_by_ip[entry.ip_address] += 1
        
        for ip, count in errors_by_ip.items():
            if count > 10:  # Порог для подозрительной активности
                suspicious_ips.add(ip)
        
        return suspicious_ips
 
# Использование системы
def main() -> None:
    log_path = Path("server_logs.txt")
    source = FileLogSource(log_path)
    analyzer = LogAnalyzer(source)
    
    print("Топ-5 активных IP:")
    for ip, count in analyzer.get_top_ips(5):
        print(f"{ip}: {count} запросов")
    
    print("\nПотенциальные атаки от IP:")
    for ip in analyzer.find_potential_attacks():
        print(f"Подозрительная активность: {ip}")
    
    print("\nСтатистика по страницам:")
    path_stats = analyzer.get_path_stats()
    for path, stats in sorted(path_stats.items(), key=lambda x: x[1]["count"], reverse=True)[:3]:
        print(f"{path}: {stats['count']} запросов, {stats['avg_time']:.2f} мс в среднем")
 
if __name__ == "__main__":
    main()