Back to Portfolio
VelociType - Test de Vitesse de Frappe
Application Python - Tkinter
Projet Actif

VelociType — Test de Vitesse de Frappe

Application Python moderne développée avec Tkinter pour tester et améliorer la vitesse de frappe. Interface intuitive avec différents niveaux de difficulté, statistiques détaillées et système de progression.

Vue d'ensemble du projet

VelociType est une application Python complète développée avec Tkinterpour tester et améliorer la vitesse de frappe. L'application propose une interface moderne et intuitive avec différents niveaux de difficulté adaptés aux utilisateurs débutants, intermédiaires et avancés.

Le projet intègre un système de chronométrage précis, des statistiques détaillées incluant WPM (Words Per Minute), CPM (Characters Per Minute), et le calcul de la précision. Les données sont sauvegardées localement en JSON pour permettre le suivi des progrès dans le temps.

L'interface utilisateur moderne utilise des couleurs vives, des animations fluides et une barre de progression en temps réel. Le système de niveaux propose des textes adaptés à chaque compétence, de phrases simples pour débutants à des textes techniques complexes pour utilisateurs avancés.

Fonctionnalités clés

⌨️ Interface moderne avec Tkinter et design responsive
📊 Trois niveaux de difficulté : Débutant, Intermédiaire, Avancé
⏱️ Chronométrage précis avec barre de progression en temps réel
📈 Calcul automatique WPM, CPM et précision de frappe
💾 Sauvegarde des statistiques en JSON avec historique complet
🏆 Système de records personnels et suivi des progrès
📋 Textes d'exercice variés adaptés à chaque niveau
🎨 Interface colorée avec feedback visuel immédiat

Implémentation du code

1. Import des bibliothèques

import tkinter as tk
from tkinter import ttk, messagebox
import time
import random
import json
import os
from datetime import datetime

2. Structure de la classe principale

class TestVitesseFrappe:
    def __init__(self):
        # Configuration de base
        self.fenetre = tk.Tk()
        self.fenetre.title("🚀 Test de Vitesse de Frappe - Version Pro")
        self.fenetre.geometry("900x650")
        self.fenetre.configure(bg="#f8f9fa")
        
        # Variables du test
        self.texte_a_taper = ""
        self.temps_debut = 0
        self.test_en_cours = False
        self.temps_limite = 60  # secondes
        
        # Textes d'exercice par niveau
        self.textes_exercice = {
            "Débutant": [...],
            "Intermédiaire": [...],
            "Avancé": [...]
        }

3. Création de l'interface utilisateur

def creer_interface(self):
    """Crée une interface moderne et intuitive"""
    
    # Titre principal
    self.creer_titre()
    
    # Panel de configuration
    self.creer_panel_configuration()
    
    # Zone du texte à taper
    self.creer_zone_texte()
    
    # Zone de saisie
    self.creer_zone_saisie()
    
    # Boutons de contrôle
    self.creer_boutons()
    
    # Barre de progression
    self.creer_barre_progression()
    
    # Zone de résultats
    self.creer_zone_resultats()
    
    # Statistiques
    self.creer_statistiques()

4. Logique de test et calcul des scores

def finir_test(self, event=None):
    """Termine le test et calcule les résultats"""
    if not self.test_en_cours:
        return
    
    texte_tape = self.zone_saisie.get(1.0, tk.END).strip()
    temps_ecoule = time.time() - self.temps_debut
    
    # Calculer la vitesse
    nombre_mots = len(texte_tape.split())
    nombre_caracteres = len(texte_tape)
    
    if temps_ecoule > 0:
        wpm = (nombre_mots / temps_ecoule) * 60
        cpm = (nombre_caracteres / temps_ecoule) * 60
    else:
        wpm = 0
        cpm = 0
    
    # Calculer la précision
    if len(self.texte_a_taper) > 0:
        caracteres_corrects = sum(1 for i, c in enumerate(texte_tape) 
                                if i < len(self.texte_a_taper) and c == self.texte_a_taper[i])
        precision = (caracteres_corrects / len(self.texte_a_taper)) * 100
    else:
        precision = 0

5. Gestion des statistiques

def sauvegarder_statistiques(self):
    """Sauvegarde les statistiques dans le fichier"""
    try:
        with open(self.fichier_stats, 'w', encoding='utf-8') as f:
            json.dump({
                "nombre_tests": self.nombre_tests,
                "meilleur_score": self.meilleur_score,
                "scores_historique": self.scores_historique
            }, f, indent=2, ensure_ascii=False)
    except Exception as e:
        print(f"Erreur lors de la sauvegarde: {e}")

def charger_statistiques(self):
    """Charge les statistiques depuis le fichier"""
    if os.path.exists(self.fichier_stats):
        try:
            with open(self.fichier_stats, 'r', encoding='utf-8') as f:
                data = json.load(f)
                self.nombre_tests = data.get("nombre_tests", 0)
                self.meilleur_score = data.get("meilleur_score", 0)
                self.scores_historique = data.get("scores_historique", [])
        except Exception as e:
            print(f"Erreur lors du chargement: {e}")

Technologies utilisées

Python
Tkinter
JSON
TTK
Datetime
Random
OS

Détails du projet

Client

Projet Personnel

Timeline

2025 – Présent

Rôle

Développeur Python

Fonctionnalités de l'application

Interface: Design moderne avec Tkinter et TTK
Niveaux: Débutant, Intermédiaire, Avancé
Métriques: WPM, CPM, Précision, Temps
Persistance: Sauvegarde JSON des statistiques
Progression: Historique complet et records
Export: Fonction d'export des données
Feedback: Validation en temps réel

Métriques de performance

Vitesse de calcul

Temps réel

Précision

Caractère par caractère

Persistance

JSON local

Interface

900x650px responsive

© 2026 Sina Ganji. All rights reserved.

0%