Просмотр кода страницы Сбор и анализ статей об искусстве

===Статья: WikiArtAnalyzer — анализатор статей Википедии об искусстве===
'''WikiArtAnalyzer''' — это Python-библиотека для комплексного анализа статей русскоязычной Википедии, посвященных искусству и смежным темам. Программа осуществляет многоуровневый анализ текстового контента, структуры статей и их категоризации, предоставляя качественную оценку и сравнительную статистику.
====Обзор====
Скрипт предназначен для исследователей, кураторов и энтузиастов искусства, позволяя автоматически:
#	Собирать статьи по заданным темам искусства
#	Анализировать текстовую сложность и структуру статей
#	Определять тематическую принадлежность через категории
#	Выявлять ключевую терминологию
#	Оценивать качество статей по комплексным критериям
#	Генерировать структурированные отчеты в различных форматах
====Архитектура системы====
=====Основной класс: WikiArtAnalyzer  ===== 
Класс инкапсулирует всю функциональность анализатора и содержит следующие ключевые компоненты:

1. Методы сбора данных
*	get_article_content() — получение полного содержимого статьи с метаданными
*	search_articles() — поиск статей по ключевым словам через API Википедии
2. Аналитические модули
*	analyze_text_complexity() — анализ лингвистической сложности текста
*	analyze_categories() — классификация статей по художественным направлениям
*	analyze_content_keywords() — выявление ключевых терминов
*	analyze_article_structure() — анализ структурных элементов статьи
3. Оценочные функции
*	calculate_article_quality_score() — расчет комплексной оценки качества
*	generate_summary_report() — агрегация результатов множественного анализа
====Детальное описание функциональности====
=====Сбор данных через MediaWiki API=====
Анализатор использует официальное API Википедии с параметрами:
*	action=query — основной метод запроса данных
*	prop=extracts|info|categories — получение контента, метаданных и категорий
*	explaintext=True — чистый текст без разметки
*	cllimit=max — максимальное количество категорий
Для каждой статьи собирается:
*	Полный текст содержимого
*	URL статьи
*	Количество слов (wordcount)
*	Список категорий
*	Дата последнего изменения
=====Лингвистический анализ сложности текста=====
Метод analyze_text_complexity() вычисляет:
1.	Объемные показатели:
*	Общее количество слов (только русские слова от 3 букв)
*	Количество предложений
2.	Качественные метрики:
*	Средняя длина слов (в символах)
*	Средняя длина предложений (в словах)
*	Частота знаков препинания на предложение
Формулы расчета:
*	Средняя длина слова: Σ(длина словаᵢ) / N
*	Средняя длина предложения: количество слов / количество предложений
*	Плотность пунктуации: количество знаков препинания / количество предложений
=====Тематическая классификация=====
Метод analyze_categories() классифицирует статьи по 7 основным художественным направлениям:
{| class="wikitable"
|+ 
|-
! Направление !! Ключевые слова для идентификации
|-
| Изобразительное || живопись, скульптура, рисунок, графика
|-
| Музыкальное || музыка, композитор, опера, симфония
|-
| Театральное || театр, драма, актёр, режиссёр театра
|-
| Литературное || литература, писатель, поэт, роман
|-
| Кино || кино, фильм, кинематограф, режиссёр
|-
| Архитектура || архитектура, здание, сооружение
|-
| Другое || все остальные категории
|}

Алгоритм определяет основную тематику статьи на основе частоты встречаемости тематических ключевых слов в её категориях.
=====Анализ ключевых терминов=====
Метод analyze_content_keywords() осуществляет:
1.	Фильтрация текста:
*	Выделение русских слов от 4 букв
*	Удаление стоп-слов (служебных слов)
2.	Частотный анализ:
*	Подсчет 15 наиболее частых слов
*	Специальный поиск 17 художественных терминов
3.	Расчет показателей:
*	Коэффициент художественной терминологии = (найденные художественные термины) / (все художественные термины)
=====Структурный анализ статей=====
Метод analyze_article_structure() выявляет:
*	Количество разделов — по заголовкам формата ==Заголовок==
*	Внутренние ссылки — на другие статьи Википедии 
*	Внешние ссылки — на внешние ресурсы 
*	Изображения — файлы в Википедии
*	Типы разделов — первые 5 уникальных заголовков
=====Система оценки качества статей=====
Метод calculate_article_quality_score() использует 5 критериев с максимальной оценкой 20 баллов каждый:
1.	Объем статьи (макс. 20 баллов):
*	500 слов: 20 баллов
*	200-500 слов: 10 баллов
2.	Структура (макс. 20 баллов):
*	≥3 разделов: 20 баллов
*	1-2 раздела: 10 баллов
3.	Связанность (макс. 20 баллов):
*	10 внутренних ссылок: 20 баллов
*	5-10 ссылок: 10 баллов
4.	Категоризация (макс. 20 баллов):
*	≥3 художественных категорий: 20 баллов
*	1-2 категории: 10 баллов
5.	Терминология (макс. 20 баллов):
*	50% художественных терминов: 20 баллов
*	20-50% терминов: 10 баллов
Итоговая оценка: сумма баллов преобразуется в проценты, определяется уровень:
*	80-100%: "Отличная"
*	60-79%: "Хорошая"
*	40-59%: "Средняя"
*	0-39%: "Базовая"
====Рабочий процесс анализа====
=====Этап 1: Подготовка=====
<syntaxhighlight lang="python">
ART_TOPICS = ['искусство', 'живопись', 'скульптура']
ARTICLES_PER_TOPIC = 2
analyzer = WikiArtAnalyzer()
</syntaxhighlight>
=====Этап 2: Сбор статей=====
#	Поиск статей по каждой теме через search_articles()
#	Фильтрация дубликатов по названиям
#	Последовательная загрузка содержимого
=====Этап 3: Анализ=====
Для каждой статьи выполняются последовательно:
#	Анализ сложности текста
#	Классификация по категориям
#	Выявление ключевых слов
#	Структурный анализ
#	Расчет оценки качества
=====Этап 4: Агрегация результатов=====
1.	Генерация сводного отчета с распределением:
*	По тематикам
*	По уровням качества
*	Топ ключевых слов
*	Рейтинг лучших статей
2.	Расчет средних значений:
*	Средняя длина статей
*	Распределение по направлениям искусства
=====Этап 5: Экспорт результатов=====
Создаются три файла:
#	Детальный анализ (JSON) — полные данные по каждой статье
#	Сводный отчет (JSON) — агрегированная статистика
#	Текстовый отчет (TXT) — форматированный человеко-читаемый отчет
====Технические особенности====
=====Обработка текста=====
*	Использование регулярных выражений для токенизации
*	Учет русской буквы "ё" в шаблонах
*	Эффективное удаление вики-разметки
*	Нормализация регистра для анализа
=====Управление запросами=====
*	Таймауты соединения (10 секунд)
*	Пользовательские заголовки User-Agent
*	Задержки между запросами (0.5 секунд)
*	Обработка сетевых ошибок и исключений
=====Структура данных=====
*	Словари для хранения промежуточных результатов
*	Использование Counter для частотного анализа
*	Иерархическая организация данных анализа
*	Временные метки для отслеживания времени выполнения

====Код на языке Python====
<syntaxhighlight lang="python">
import requests
import json
import re
from collections import Counter
from datetime import datetime
import time

class WikiArtAnalyzer:
    def __init__(self):
        self.base_url = "https://ru.wikipedia.org/w/api.php"
        self.headers = {
            'User-Agent': 'WikiArtAnalyzer/1.0'
        }
    
    def get_article_content(self, title):
        """Получение полного содержания статьи"""
        params = {
            'action': 'query',
            'format': 'json',
            'titles': title,
            'prop': 'extracts|info|categories',
            'explaintext': True,
            'inprop': 'url',
            'cllimit': 'max'
        }
        
        try:
            response = requests.get(
                self.base_url, 
                params=params,
                headers=self.headers,
                timeout=10
            )
            data = response.json()
            
            pages = data.get('query', {}).get('pages', {})
            if not pages:
                return None
            
            page_id = list(pages.keys())[0]
            page_data = pages[page_id]
            
            if 'missing' in page_data:
                return None
            
            return {
                'title': page_data.get('title', ''),
                'url': page_data.get('fullurl', ''),
                'content': page_data.get('extract', ''),
                'wordcount': page_data.get('wordcount', 0),
                'categories': [cat['title'] for cat in page_data.get('categories', [])],
                'last_modified': page_data.get('touched', '')
            }
        except Exception as e:
            print(f"Ошибка при получении статьи {title}: {e}")
            return None
    
    def search_articles(self, query, limit=10):
        """Поиск статей по запросу"""
        params = {
            'action': 'query',
            'format': 'json',
            'list': 'search',
            'srsearch': query,
            'srlimit': limit,
            'srprop': 'snippet|wordcount'
        }
        
        response = requests.get(self.base_url, params=params, headers=self.headers)
        data = response.json()
        
        articles = []
        for item in data.get('query', {}).get('search', []):
            articles.append({
                'title': item['title'],
                'snippet': item['snippet'],
                'wordcount': item.get('wordcount', 0)
            })
        
        return articles
    
    def analyze_text_complexity(self, text):
        """Анализ сложности текста"""
        if not text:
            return {}
        
        words = re.findall(r'\b[а-яА-ЯёЁ]{3,}\b', text)
        sentences = re.split(r'[.!?]+', text)
        
        # Убираем пустые строки
        sentences = [s.strip() for s in sentences if s.strip()]
        
        if not words or not sentences:
            return {}
        
        # Средняя длина слов
        avg_word_len = sum(len(w) for w in words) / len(words)
        
        # Средняя длина предложений
        avg_sentence_len_words = len(words) / len(sentences)
        
        # Частота использования знаков препинания
        punctuation_count = len(re.findall(r'[,.!?:;]', text))
        punctuation_per_sentence = punctuation_count / len(sentences) if sentences else 0
        
        return {
            'word_count': len(words),
            'sentence_count': len(sentences),
            'avg_word_length': round(avg_word_len, 2),
            'avg_sentence_length_words': round(avg_sentence_len_words, 2),
            'punctuation_density': round(punctuation_per_sentence, 2)
        }
    
    def analyze_categories(self, categories):
        """Анализ категорий статьи"""
        if not categories:
            return {}
        
        art_related_keywords = [
            'искусство', 'живопись', 'скульптура', 'архитектура',
            'музыка', 'театр', 'кино', 'литература', 'художник',
            'композитор', 'писатель', 'архитектор', 'режиссёр'
        ]
        
        # Определение основных тематик
        themes = {
            'изобразительное': 0,
            'музыкальное': 0,
            'театральное': 0,
            'литературное': 0,
            'кино': 0,
            'архитектура': 0,
            'другое': 0
        }
        
        art_categories = []
        for category in categories:
            cat_lower = category.lower()
            art_categories.append(category)
            
            # Определение тематики
            if any(keyword in cat_lower for keyword in ['живопись', 'скульптура', 'рисунок', 'графика']):
                themes['изобразительное'] += 1
            elif any(keyword in cat_lower for keyword in ['музыка', 'композитор', 'опера', 'симфония']):
                themes['музыкальное'] += 1
            elif any(keyword in cat_lower for keyword in ['театр', 'драма', 'актёр', 'режиссёр театра']):
                themes['театральное'] += 1
            elif any(keyword in cat_lower for keyword in ['литература', 'писатель', 'поэт', 'роман']):
                themes['литературное'] += 1
            elif any(keyword in cat_lower for keyword in ['кино', 'фильм', 'кинематограф', 'режиссёр']):
                themes['кино'] += 1
            elif any(keyword in cat_lower for keyword in ['архитектура', 'здание', 'сооружение']):
                themes['архитектура'] += 1
            else:
                themes['другое'] += 1
        
        # Определение основной тематики
        main_theme = max(themes, key=themes.get) if any(themes.values()) else 'другое'
        
        return {
            'total_categories': len(categories),
            'art_categories_count': len(art_categories),
            'main_theme': main_theme,
            'themes_distribution': themes
        }
    
    def analyze_content_keywords(self, text):
        """Анализ ключевых слов в контенте"""
        if not text:
            return {}
        
        # Удаляем стоп-слова
        stop_words = {'это', 'что', 'как', 'так', 'для', 'или', 'но', 'они', 
                     'мы', 'вы', 'его', 'её', 'их', 'все', 'всех', 'когда', 
                     'где', 'кто', 'чем', 'там', 'тут', 'после', 'очень'}
        
        words = re.findall(r'\b[а-яА-ЯёЁ]{4,}\b', text.lower())
        filtered_words = [w for w in words if w not in stop_words]
        
        # Находим наиболее частые слова
        word_freq = Counter(filtered_words)
        top_keywords = word_freq.most_common(15)
        
        # Ключевые слова, связанные с искусством
        art_keywords = ['художник', 'картина', 'произведение', 'искусство', 
                       'музей', 'выставка', 'творчество', 'стиль', 'эпоха',
                       'полотно', 'скульптура', 'архитектор', 'композитор',
                       'литература', 'театр', 'кино', 'музыка']
        
        found_art_keywords = [(kw, word_freq[kw]) for kw in art_keywords if kw in word_freq]
        
        return {
            'total_words': len(filtered_words),
            'top_keywords': [{'word': w, 'count': c} for w, c in top_keywords],
            'art_keywords_found': [{'word': w, 'count': c} for w, c in found_art_keywords],
            'art_keywords_ratio': len(found_art_keywords) / len(art_keywords) if art_keywords else 0
        }
    
    def analyze_article_structure(self, text):
        """Анализ структуры статьи"""
        if not text:
            return {}
        
        # Разделы (определяются по заголовкам в тексте)
        sections = re.findall(r'\n==[^=]+==\n', text)
        
        # Ссылки на другие статьи (в тексте)
        internal_links = re.findall(r'\[\[([^|\]]+)', text)
        
        # Внешние ссылки
        external_links = re.findall(r'\[https?://[^\s\]]+', text)
        
        # Изображения и медиа
        images = re.findall(r'\[\[[Фф]айл:[^\]]+\]\]', text)
        
        # Уникальные типы разделов (первые 5)
        section_types = list(set([s.strip('=\n ') for s in sections]))
        section_types = section_types[:5] if len(section_types) > 5 else section_types
        
        return {
            'section_count': len(sections),
            'internal_links_count': len(internal_links),
            'external_links_count': len(external_links),
            'images_count': len(images),
            'section_types': section_types
        }
    
    def calculate_article_quality_score(self, analysis):
        """Расчет оценки качества статьи"""
        score = 0
        max_score = 100
        
        # Оценка объема
        if analysis.get('complexity', {}).get('word_count', 0) > 500:
            score += 20
        elif analysis.get('complexity', {}).get('word_count', 0) > 200:
            score += 10
        
        # Оценка структуры
        if analysis.get('structure', {}).get('section_count', 0) >= 3:
            score += 20
        elif analysis.get('structure', {}).get('section_count', 0) >= 1:
            score += 10
        
        # Оценка связанности (ссылки)
        if analysis.get('structure', {}).get('internal_links_count', 0) > 10:
            score += 20
        elif analysis.get('structure', {}).get('internal_links_count', 0) > 5:
            score += 10
        
        # Оценка категорий
        if analysis.get('categories', {}).get('art_categories_count', 0) >= 3:
            score += 20
        elif analysis.get('categories', {}).get('art_categories_count', 0) >= 1:
            score += 10
        
        # Оценка ключевых слов искусства
        if analysis.get('keywords', {}).get('art_keywords_ratio', 0) > 0.5:
            score += 20
        elif analysis.get('keywords', {}).get('art_keywords_ratio', 0) > 0.2:
            score += 10
        
        return {
            'score': score,
            'max_score': max_score,
            'percentage': round((score / max_score) * 100, 1) if max_score > 0 else 0
        }
    
    def analyze_single_article(self, title):
        """Полный анализ одной статьи"""
        print(f"Анализ статьи: {title}")
        
        # Получаем содержание статьи
        article_data = self.get_article_content(title)
        if not article_data:
            print(f"Статья {title} не найдена или произошла ошибка")
            return None
        
        # Выполняем все виды анализа
        analysis = {
            'metadata': {
                'title': article_data['title'],
                'url': article_data['url'],
                'wordcount': article_data['wordcount'],
                'timestamp': datetime.now().isoformat()
            }
        }
        
        # Анализ сложности текста
        complexity_analysis = self.analyze_text_complexity(article_data['content'])
        analysis['complexity'] = complexity_analysis
        
        # Анализ категорий
        categories_analysis = self.analyze_categories(article_data['categories'])
        analysis['categories'] = categories_analysis
        
        # Анализ ключевых слов
        keywords_analysis = self.analyze_content_keywords(article_data['content'])
        analysis['keywords'] = keywords_analysis
        
        # Анализ структуры
        structure_analysis = self.analyze_article_structure(article_data['content'])
        analysis['structure'] = structure_analysis
        
        # Рассчитываем оценку качества
        quality_score = self.calculate_article_quality_score(analysis)
        analysis['quality_score'] = quality_score
        
        # Определяем уровень статьи
        score_percentage = quality_score['percentage']
        if score_percentage >= 80:
            level = "Отличная"
        elif score_percentage >= 60:
            level = "Хорошая"
        elif score_percentage >= 40:
            level = "Средняя"
        else:
            level = "Базовая"
        
        analysis['metadata']['article_level'] = level
        
        return analysis
    
    def analyze_multiple_articles(self, topics, articles_per_topic=2):
        """Анализ нескольких статей по темам"""
        all_analyses = []
        seen_titles = set()
        
        print("=" * 60)
        print("СБОР И АНАЛИЗ СТАТЕЙ ОБ ИСКУССТВЕ")
        print("=" * 60)
        
        for topic in topics:
            print(f"\n🔍 Поиск статей по теме: {topic}")
            
            # Ищем статьи по теме
            articles = self.search_articles(topic, limit=articles_per_topic * 2)
            
            analyzed_count = 0
            for article in articles:
                if article['title'] in seen_titles:
                    continue
                
                # Анализируем статью
                analysis = self.analyze_single_article(article['title'])
                if analysis:
                    all_analyses.append(analysis)
                    seen_titles.add(article['title'])
                    analyzed_count += 1
                    
                    if analyzed_count >= articles_per_topic:
                        break
                
                time.sleep(0.5)  # Задержка между запросами
            
            print(f"   Проанализировано статей: {analyzed_count}")
        
        return all_analyses
    
    def generate_summary_report(self, analyses):
        """Генерация сводного отчета"""
        if not analyses:
            return {}
        
        summary = {
            'total_articles': len(analyses),
            'themes_distribution': Counter(),
            'quality_distribution': Counter(),
            'avg_word_count': 0,
            'top_keywords_all': Counter(),
            'best_articles': []
        }
        
        total_words = 0
        
        for analysis in analyses:
            # Распределение по темам
            theme = analysis['categories'].get('main_theme', 'другое')
            summary['themes_distribution'][theme] += 1
            
            # Распределение по качеству
            level = analysis['metadata'].get('article_level', 'Неизвестно')
            summary['quality_distribution'][level] += 1
            
            # Счетчик слов
            word_count = analysis['complexity'].get('word_count', 0)
            total_words += word_count
            
            # Ключевые слова
            for kw in analysis['keywords'].get('top_keywords', []):
                summary['top_keywords_all'][kw['word']] += kw['count']
            
            # Лучшие статьи (сортировка по оценке)
            summary['best_articles'].append({
                'title': analysis['metadata']['title'],
                'score': analysis['quality_score']['percentage'],
                'level': level,
                'theme': theme
            })
        
        # Средние значения
        if len(analyses) > 0:
            summary['avg_word_count'] = round(total_words / len(analyses), 1)
        else:
            summary['avg_word_count'] = 0
        
        # Сортируем лучшие статьи
        summary['best_articles'].sort(key=lambda x: x['score'], reverse=True)
        summary['best_articles'] = summary['best_articles'][:10]
        
        # Топ ключевые слова
        summary['top_keywords_all'] = dict(summary['top_keywords_all'].most_common(20))
        
        return summary
    
    def save_results(self, analyses, summary, filename_prefix='wiki_art_analysis'):
        """Сохранение результатов анализа"""
        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
        
        # Сохраняем детальный анализ
        details_filename = f"{filename_prefix}_details_{timestamp}.json"
        with open(details_filename, 'w', encoding='utf-8') as f:
            json.dump(analyses, f, ensure_ascii=False, indent=2)
        
        # Сохраняем сводный отчет
        summary_filename = f"{filename_prefix}_summary_{timestamp}.json"
        with open(summary_filename, 'w', encoding='utf-8') as f:
            json.dump(summary, f, ensure_ascii=False, indent=2)
        
        # Генерируем текстовый отчет
        report_filename = f"{filename_prefix}_report_{timestamp}.txt"
        self.generate_text_report(analyses, summary, report_filename)
        
        print(f"\n📁 Результаты сохранены в файлы:")
        print(f"   • Детальный анализ: {details_filename}")
        print(f"   • Сводный отчет: {summary_filename}")
        print(f"   • Текстовый отчет: {report_filename}")
        
        return details_filename, summary_filename, report_filename
    
    def generate_text_report(self, analyses, summary, filename):
        """Создание текстового отчета"""
        with open(filename, 'w', encoding='utf-8') as f:
            f.write("=" * 70 + "\n")
            f.write("АНАЛИЗ СТАТЕЙ ВИКИПЕДИИ ОБ ИСКУССТВЕ\n")
            f.write("=" * 70 + "\n\n")
            
            f.write("📊 ОБЩАЯ СТАТИСТИКА:\n")
            f.write(f"Всего проанализировано статей: {summary['total_articles']}\n")
            f.write(f"Среднее количество слов в статье: {summary['avg_word_count']}\n\n")
            
            f.write("🎨 РАСПРЕДЕЛЕНИЕ ПО ТЕМАТИКАМ:\n")
            for theme, count in summary['themes_distribution'].items():
                percentage = (count / summary['total_articles']) * 100
                f.write(f"  {theme}: {count} статей ({percentage:.1f}%)\n")
            
            f.write("\n🏆 КАЧЕСТВО СТАТЕЙ:\n")
            for level, count in summary['quality_distribution'].items():
                percentage = (count / summary['total_articles']) * 100
                f.write(f"  {level}: {count} статей ({percentage:.1f}%)\n")
            
            f.write("\n🔑 ТОП-10 КЛЮЧЕВЫХ СЛОВ:\n")
            top_words = list(summary['top_keywords_all'].items())[:10]
            for word, count in top_words:
                f.write(f"  {word}: {count} упоминаний\n")
            
            f.write("\n⭐ ТОП-5 ЛУЧШИХ СТАТЕЙ:\n")
            for i, article in enumerate(summary['best_articles'][:5], 1):
                f.write(f"{i}. {article['title']}\n")
                f.write(f"   Оценка: {article['score']}% | Уровень: {article['level']} | Тема: {article['theme']}\n\n")
            
            f.write("=" * 70 + "\n")
            f.write("ДЕТАЛЬНЫЙ АНАЛИЗ ПЕРВЫХ 3 СТАТЕЙ:\n")
            f.write("=" * 70 + "\n\n")
            
            for i, analysis in enumerate(analyses[:3], 1):
                f.write(f"📄 СТАТЬЯ {i}: {analysis['metadata']['title']}\n")
                f.write(f"URL: {analysis['metadata']['url']}\n")
                f.write(f"Уровень: {analysis['metadata']['article_level']}\n")
                f.write(f"Оценка качества: {analysis['quality_score']['percentage']}%\n")
                f.write(f"Основная тема: {analysis['categories'].get('main_theme', 'Не определена')}\n")
                f.write(f"Количество слов: {analysis['complexity'].get('word_count', 0)}\n")
                f.write(f"Количество разделов: {analysis['structure'].get('section_count', 0)}\n")
                
                # Ключевые слова
                art_keywords = [kw['word'] for kw in analysis['keywords'].get('art_keywords_found', [])]
                if art_keywords:
                    f.write(f"Ключевые слова искусства: {', '.join(art_keywords[:5])}\n")
                
                f.write("\n" + "-" * 50 + "\n\n")

def main():
    """Основная функция"""
    
    # Настройки анализа - УМЕНЬШИМ для тестирования
    ART_TOPICS = [
        'искусство',
        'живопись',
        'скульптура'
    ]
    
    ARTICLES_PER_TOPIC = 100  # Уменьшаем для тестирования
    
    # Создаем анализатор
    analyzer = WikiArtAnalyzer()
    
    print("🚀 Запуск анализа статей Википедии об искусстве...")
    print(f"Темы для анализа: {', '.join(ART_TOPICS)}")
    print(f"Статей на тему: {ARTICLES_PER_TOPIC}")
    print("\n" + "=" * 60)
    
    # Анализируем статьи
    analyses = analyzer.analyze_multiple_articles(ART_TOPICS, ARTICLES_PER_TOPIC)
    
    if not analyses:
        print("\n❌ Не удалось проанализировать статьи")
        return
    
    # Генерируем сводный отчет
    summary = analyzer.generate_summary_report(analyses)
    
    # Сохраняем результаты
    analyzer.save_results(analyses, summary)
    
    # Выводим краткую статистику в консоль
    print("\n" + "=" * 60)
    print("📈 КРАТКАЯ СТАТИСТИКА:")
    print(f"Всего проанализировано статей: {summary['total_articles']}")
    print(f"Средняя длина статьи: {summary['avg_word_count']} слов")
    
    if summary['best_articles']:
        print("\n🏆 ЛУЧШИЕ СТАТЬИ:")
        for i, article in enumerate(summary['best_articles'][:3], 1):
            print(f"{i}. {article['title']} - {article['score']}%")
    
    print("\n✅ Анализ завершен!")

if __name__ == "__main__":
    main()
</syntaxhighlight>
=====Пример вывода программы=====

СБОР И АНАЛИЗ СТАТЕЙ ОБ ИСКУССТВЕ

🔍 Поиск статей по теме: искусство
Анализ статьи: Искусство
   ✓ Слов: 1250 | Разделов: 8 | Оценка: 85% | Уровень: Отличная
Анализ статьи: История искусства
   ✓ Слов: 980 | Разделов: 5 | Оценка: 75% | Уровень: Хорошая

📊 ОБЩАЯ СТАТИСТИКА:
Всего проанализировано статей: 6
Среднее количество слов в статье: 875.5

🎨 РАСПРЕДЕЛЕНИЕ ПО ТЕМАТИКАМ:
  изобразительное: 3 статей (50.0%)
  музыкальное: 1 статей (16.7%)
  архитектура: 1 статей (16.7%)
  другое: 1 статей (16.7%)
====Методологическая ценность====
=====Для исследования искусства=====
*	Количественный анализ терминологических полей
*	Выявление взаимосвязей между художественными направлениями
*	Сравнительный анализ охвата различных тем
=====Для кураторов контента=====
*	Объективная оценка качества статей
*	Выявление пробелов в освещении тем
*	Мониторинг структуры и связности материалов
=====Для цифровых гуманитариев=====
*	Пример применения computational methods в искусствоведении
*	Модель для анализа других тематических областей
*	База для сравнительных исследований

====Ограничения и направления развития====
=====Текущие ограничения=====
#	Лингвистические: отсутствие морфологического анализа
#	Контекстуальные: не учитывается семантическая связность
#	Временные: не анализируется история изменений статей
#	Визуальные: отсутствие анализа изображений и медиа-контента
=====Возможные улучшения=====
#	Интеграция с NLP-библиотеками (NLTK, spaCy)
#	Анализ эмоциональной окраски текста
#	Визуализация сетей связанных статей
#	Многоязычный анализ
#	Машинное обучение для классификации качества
====Практическое применение====
=====Образовательное=====
*	Анализ качества учебных материалов
*	Сравнение статей на одну тему на разных языках
*	Исследование эволюции терминологии
=====Кураторское=====
*	Оценка полноты освещения художественных направлений
*	Выявление приоритетных тем для дополнения
*	Мониторинг качества контента сообщества
=====Исследовательское=====
*	Анализ дискурсивных практик в искусствоведении
*	Исследование междисциплинарных связей
*	Картирование тематических областей

=====Примечания=====
Программа является инструментом поддержки принятия решений и не заменяет экспертной оценки. Рекомендуется использовать результаты анализа в сочетании с качественными методами исследования. Для production-использования рекомендуется добавить кэширование, расширенную обработку ошибок и более сложные алгоритмы анализа.