L'automatisation du téléchargement de ressources graphiques et l'analyse statistique des personnages sont des tâches courantes en ingénierie de données. Cet article explore comment utiliser Python pour extraire les skins des héros du jeu Honor of Kings et visualiser les métadonnées associées.

Dépendacnes logicielles

Pour réaliser ce projet, les bibliothèques suivantes sont nécessaires :

import requests
from bs4 import BeautifulSoup
from urllib import parse
from pyecharts.charts import WordCloud, Pie
from pyecharts import options as opts
import time
import os

Analyse de la source de données

La première étape consiste à identifier les points de terminaison (endpoints) du site officiel. Les données des héros sont généralement stockées dans un fichier JSON accessible via une API interne. En inspectant les requêtes réseau (F12 dans le navigateur), on peut isoler l'URL fournissant la liste complète des personnages avec leurs identifiants uniques (ename) et leurs noms (cname).

Implémentation du collecteur de données

Nous encapsulons la logique dans une classe pour une meilleure gestion de l'état et des URLs.

def fetch_hero_metadata(self):
    """Récupère la liste brute des héros au format JSON."""
    try:
        response = requests.get(self.api_url)
        response.raise_for_status()
        return response.json()
    except Exception as e:
        print(f"Erreur lors de la récupération : {e}")
        return []

def process_hero_skins(self, heroes):
    """Parcourt la liste des héros pour extraire les informations de skins."""
    for index, hero in enumerate(heroes):
        hero_id = str(hero['ename'])
        hero_name = hero['cname']
        self.current_detail_path = f"{hero_id}.shtml"
        
        # Logique de traitement des skins individuels
        self.parse_skin_details(f"{index}_{hero_name}", hero_id)

def extract_html_content(self):
    """Analyse la page de détails du héros pour trouver les noms des skins."""
    target_url = parse.urljoin(self.base_site_url, self.current_detail_path)
    res = requests.get(target_url)
    res.encoding = 'gbk'
    soup = BeautifulSoup(res.text, 'lxml')
    return soup.select('.pic-pf-list3')

Téléchargement automatisé des images

La structure des URLs des images de skins suit souvent un pattern prévisible basé sur l'ID du héros et l'index du skin. Il est crucial d'ajouter un délai entre les requêtes pour éviter d'être bloqué par le serveur.

def save_skin_image(self, filename, sub_url):
    """Télécharge et enregistre l'image sur le disque local."""
    full_image_url = parse.urljoin(self.image_cdn_base, sub_url)
    time.sleep(0.3)  # Temporisation pour respecter le serveur
    
    img_data = requests.get(full_image_url)
    if img_data.status_code == 200:
        file_path = os.path.join(self.output_dir, filename)
        with open(file_path, 'wb') as f:
            f.write(img_data.content)
        print(f"Succès : {filename}")
    else:
        print(f"Échec du téléchargement pour {filename}")

Visualisation des données avec PyEcharts

Une fois les données collectées, nous pouvons générer des graphiques interactifs pour analyser la répartition des héros par rôle ou le nombre de skins par personnage.

def generate_visual_cloud(self, stats_data):
    """Génère un nuage de mots basé sur le nombre de skins."""
    cloud = (
        WordCloud()
        .add("Volume de Skins", stats_data, word_size_range=[15, 60])
        .set_global_opts(title_opts=opts.TitleOpts(title="Répartition des Skins par Héros"))
    )
    cloud.render("nuage_skins_heros.html")

def plot_role_distribution(self, distribution_data):
    """Crée un diagramme circulaire des classes de héros."""
    pie_chart = (
        Pie()
        .add("Classes", distribution_data)
        .set_colors(["#5470c6", "#91cc75", "#fac858", "#ee6666", "#73c0de", "#3ba272"])
        .set_series_opts(label_opts=opts.LabelOpts(formatter="{b}: {c}"))
        .set_global_opts(title_opts=opts.TitleOpts(title="Analyse des Rôles des Héros"))
    )
    pie_chart.render("distribution_roles.html")

Cette approche permet non seulement de constituer une base d'assets locale, mais aussi de transformer des données brutes en informations exploitables via des outils de Business Intelligence programmatiques.