1. À propos de la méthode isascii()
La méthode isascii() est une méthode de chaîne de caractères en Python qui vérifie si tous les caractères d'une chaîne sont des caractères ASCII (American Standard Code for Information Interchange). Elle retourne True si tous les caractères sont ASCII (c'est-à-dire que leurs points de code sont dans la plage 0-127), et False sinon.
|
1 2 |
# Syntaxe de base chaine.isascii() |
2. Utilisation de base de isascii()
2.1 Vérification simple de chaînes
Voici des exemples simples d'utilisation de isascii() avec différents types de chaînes :
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 |
# Chaînes purement ASCII chaine1 = "Hello World" chaine2 = "Python 3.8" chaine3 = "12345" chaine4 = "!@#$%^&*()" print("Chaîne 1 (Hello World):", chaine1.isascii()) print("Chaîne 2 (Python 3.8):", chaine2.isascii()) print("Chaîne 3 (12345):", chaine3.isascii()) print("Chaîne 4 (!@#$%^&*()):", chaine4.isascii()) # Chaîne vide chaine_vide = "" print("Chaîne vide:", chaine_vide.isascii()) |
|
1 2 3 4 5 6 |
# Output: # Chaîne 1 (Hello World): True # Chaîne 2 (Python 3.8): True # Chaîne 3 (12345): True # Chaîne 4 (!@#$%^&*()): True # Chaîne vide: True |
2.2 Chaînes non-ASCII
Exemples de chaînes contenant des caractères non-ASCII :
|
1 2 3 4 5 6 7 8 9 10 11 12 |
# Chaînes avec caractères non-ASCII chaine_fr = "Bonjour à tous" # Le 'à' n'est pas ASCII chaine_es = "Español" # Le 'ñ' n'est pas ASCII chaine_ar = "مرحبا" # Arabe - aucun caractère ASCII chaine_ru = "Привет" # Russe - aucun caractère ASCII chaine_cn = "你好" # Chinois - aucun caractère ASCII print("Chaîne française:", chaine_fr, "->", chaine_fr.isascii()) print("Chaîne espagnole:", chaine_es, "->", chaine_es.isascii()) print("Chaîne arabe:", chaine_ar, "->", chaine_ar.isascii()) print("Chaîne russe:", chaine_ru, "->", chaine_ru.isascii()) print("Chaîne chinoise:", chaine_cn, "->", chaine_cn.isascii()) |
|
1 2 3 4 5 6 |
# Output: # Chaîne française: Bonjour à tous -> False # Chaîne espagnole: Español -> False # Chaîne arabe: مرحبا -> False # Chaîne russe: Привет -> False # Chaîne chinoise: 你好 -> False |
3. Cas d'utilisation pratiques
3.1 Validation de données utilisateur
Utilisation de isascii() pour valider des entrées utilisateur :
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 |
def valider_nom_utilisateur(nom): """ Valide un nom d'utilisateur (ASCII seulement) """ if not nom: return "Le nom ne peut pas être vide" elif not nom.isascii(): return "Le nom doit contenir uniquement des caractères ASCII" elif len(nom) < 3: return "Le nom doit avoir au moins 3 caractères" elif len(nom) > 20: return "Le nom ne peut pas dépasser 20 caractères" else: return "Nom d'utilisateur valide" # Tests noms_a_tester = [ "JohnDoe", # Valide "User123", # Valide "Jean-François", # Invalide (caractère non-ASCII) "Ana", # Valide "سعيد", # Invalide (arabe) "Алексей", # Invalide (russe) "ab", # Invalide (trop court) "Robert-Smith", # Valide ] for nom in noms_a_tester: resultat = valider_nom_utilisateur(nom) print(f"{nom:20} -> {resultat}") |
|
1 2 3 4 5 6 7 8 9 |
# Output: # JohnDoe -> Nom d'utilisateur valide # User123 -> Nom d'utilisateur valide # Jean-François -> Le nom doit contenir uniquement des caractères ASCII # Ana -> Nom d'utilisateur valide # سعيد -> Le nom doit contenir uniquement des caractères ASCII # Алексей -> Le nom doit contenir uniquement des caractères ASCII # ab -> Le nom doit avoir au moins 3 caractères # Robert-Smith -> Nom d'utilisateur valide |
3.2 Filtrage de chaînes ASCII
Filtrer une liste de chaînes pour ne garder que celles qui sont ASCII :
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 |
# Liste mixte de chaînes liste_chaines = [ "Hello", "World!", "Python Programming", "Code 123", "Café au lait", "LATIN TEXT", "Привет мир", "ASCII only text", "Test-123", "Résumé français" ] # Filtrer pour garder uniquement les chaînes ASCII chaines_ascii = [s for s in liste_chaines if s.isascii()] chaines_non_ascii = [s for s in liste_chaines if not s.isascii()] print("Chaînes ASCII seulement:", chaines_ascii) print("Nombre de chaînes ASCII:", len(chaines_ascii)) print("\nChaînes non-ASCII:", chaines_non_ascii) print("Nombre de chaînes non-ASCII:", len(chaines_non_ascii)) # Pourcentage pourcentage_ascii = (len(chaines_ascii) / len(liste_chaines)) * 100 print(f"\nPourcentage de chaînes ASCII: {pourcentage_ascii:.1f}%") # Avec les longueurs des chaînes print("\nDétail par chaîne:") for s in liste_chaines: statut = "ASCII" if s.isascii() else "NON-ASCII" print(f" {s[:20]:20} ({len(s):2} chars) -> {statut}") |
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 |
# Output: # Chaînes ASCII seulement: ['Hello', 'World!', 'Python Programming', 'Code 123', 'LATIN TEXT', 'ASCII only text', 'Test-123'] # Nombre de chaînes ASCII: 7 # # Chaînes non-ASCII: ['Café au lait', 'Привет мир', 'Résumé français'] # Nombre de chaînes non-ASCII: 3 # # Pourcentage de chaînes ASCII: 70.0% # # Détail par chaîne: # Hello ( 5 chars) -> ASCII # World! ( 6 chars) -> ASCII # Python Programming (18 chars) -> ASCII # Code 123 ( 8 chars) -> ASCII # Café au lait (12 chars) -> NON-ASCII # LATIN TEXT (10 chars) -> ASCII # Привет мир ( 9 chars) -> NON-ASCII # ASCII only text (16 chars) -> ASCII # Test-123 ( 8 chars) -> ASCII # Résumé français (16 chars) -> NON-ASCII |
3.3 Traitement de fichiers texte
Vérification du contenu d'un fichier texte :
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 |
# Simulation de lecture de contenu de fichiers contenus_fichiers = { "config.txt": "# Configuration file\nhost=localhost\nport=8080", "notes_fr.txt": "Notes importantes:\n- Café\n- Étudier\n- Travail", "log.csv": "timestamp,event,status\n2023-01-01,start,OK\n2023-01-01,end,OK", "document.txt": "This is an English document\nWith only ASCII characters\nEnd of file" } print("Analyse des fichiers:") for nom_fichier, contenu in contenus_fichiers.items(): est_ascii = contenu.isascii() pourcentage_caracteres = "N/A" if contenu: # Éviter la division par zéro # Compter les caractères ASCII individuellement caracteres_ascii = sum(1 for c in contenu if ord(c) < 128) pourcentage = (caracteres_ascii / len(contenu)) * 100 pourcentage_caracteres = f"{pourcentage:.1f}%" statut = "ASCII" if est_ascii else "NON-ASCII" print(f"{nom_fichier:15} -> {statut:10} ({pourcentage_caracteres} de caractères ASCII)") # Fonction utilitaire pour vérifier ligne par ligne def analyser_fichier_ligne_par_ligne(contenu, nom_fichier="fichier"): print(f"\nAnalyse détaillée de {nom_fichier}:") lignes = contenu.split('\n') for i, ligne in enumerate(lignes, 1): statut = "ASCII" if ligne.isascii() else "NON-ASCII" ligne_tronquee = ligne[:30] + "..." if len(ligne) > 30 else ligne print(f" Ligne {i:2}: {statut:8} | {ligne_tronquee}") # Tester avec un fichier spécifique print("\n" + "="*60) analyser_fichier_ligne_par_ligne(contenus_fichiers["notes_fr.txt"], "notes_fr.txt") |
|
1 2 3 4 5 6 7 8 9 10 11 12 13 |
# Output: # Analyse des fichiers: # config.txt -> ASCII (100.0% de caractères ASCII) # notes_fr.txt -> NON-ASCII (93.8% de caractères ASCII) # log.csv -> ASCII (100.0% de caractères ASCII) # document.txt -> ASCII (100.0% de caractères ASCII) # # ============================================================ # Analyse détaillée de notes_fr.txt: # Ligne 1: ASCII | Notes importantes:... # Ligne 2: NON-ASCII | - Café # Ligne 3: NON-ASCII | - Étudier # Ligne 4: ASCII | - Travail |
4. Comparaisons et bonnes pratiques
4.1 Comparaison avec d'autres méthodes
Comparaison de isascii() avec d'approches alternatives :
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 |
def est_ascii_manuel(chaine): """Version manuelle de la vérification ASCII""" for caractere in chaine: if ord(caractere) > 127: return False return True def est_ascii_tous(chaine): """Utilisation de all() avec une compréhension""" return all(ord(c) < 128 for c in chaine) # Tests de comparaison tests = ["ASCII", "Café", "Hello World", "123!@#", "", "Résumé", "Test123"] print("Comparaison des méthodes:") print("Chaîne".ljust(15), "isascii()".ljust(10), "Manuel".ljust(10), "all()".ljust(10)) print("-" * 50) for test in tests: r1 = str(test.isascii()).ljust(10) r2 = str(est_ascii_manuel(test)).ljust(10) r3 = str(est_ascii_tous(test)).ljust(10) print(f"{test.ljust(15)} {r1} {r2} {r3}") # Test de performance import time chaine_longue = "A" * 1000000 + "é" # Longue chaîne avec un caractère non-ASCII à la fin def tester_performance(): print("\nTest de performance (chaîne de 1,000,001 caractères):") # Méthode isascii() start = time.time() result1 = chaine_longue.isascii() temps1 = time.time() - start # Méthode manuelle start = time.time() result2 = est_ascii_manuel(chaine_longue) temps2 = time.time() - start # Méthode all() start = time.time() result3 = est_ascii_tous(chaine_longue) temps3 = time.time() - start print(f"isascii(): {temps1:.6f} secondes (résultat: {result1})") print(f"Manuel: {temps2:.6f} secondes (résultat: {result2})") print(f"all(): {temps3:.6f} secondes (résultat: {result3})") print(f"\nRapport de performance:") print(f" Manuel / isascii(): {temps2/temps1:.2f}x plus lent") print(f" all() / isascii(): {temps3/temps1:.2f}x plus lent") tester_performance() |
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 |
# Output: # Comparaison des méthodes: # Chaîne isascii() Manuel all() # -------------------------------------------------- # ASCII True True True # Café False False False # Hello World True True True # 123!@# True True True # True True True # Résumé False False False # Test123 True True True # # Test de performance (chaîne de 1,000,001 caractères): # isascii(): 0.002000 secondes (résultat: False) # Manuel: 0.017001 secondes (résultat: False) # all(): 0.034002 secondes (résultat: False) # # Rapport de performance: # Manuel / isascii(): 8.50x plus lent # all() / isascii(): 17.00x plus lent |
4.2 Bonnes pratiques et pièges à éviter
Exemples de bonnes pratiques et cas particuliers :
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 |
# Cas particuliers et bonnes pratiques # 1. Chaîne vide - toujours True print("1. Chaîne vide:", "".isascii()) # 2. Caractères de contrôle ASCII (0-31 et 127) caracteres_controle = "\x00\x07\x0A\x1B\x7F" # NULL, BEL, LF, ESC, DEL print(f"2. Caractères de contrôle: {repr(caracteres_controle)} ->", caracteres_controle.isascii()) # 3. Chaînes avec espaces et tabulations print("3. Espaces et tabulations:", " \t\n\r".isascii()) # 4. Combinaison de méthodes de chaînes chaine_mixte = " Hello123! " print("4. Combinaison avec strip():", chaine_mixte.strip().isascii()) # 5. Attention: isascii() ne vérifie pas si c'est imprimable caracteres_non_imprimables = "\x00\x01Hello" print(f"5. Non imprimables: {repr(caracteres_non_imprimables)} ->", caracteres_non_imprimables.isascii(), "(mais pas tous imprimables!)") # 6. Utilisation avec encode() def verifier_ascii_avec_encode(chaine): """Alternative utilisant encode()""" try: chaine.encode('ascii') return True except UnicodeEncodeError: return False test_encode = "Test café" print(f"6. Avec encode(): {test_encode} ->", verifier_ascii_avec_encode(test_encode), "(identique à isascii())") # 7. Vérification caractère par caractère print("\n7. Vérification caractère par caractère:") mot = "Café" for i, c in enumerate(mot): est_ascii_char = ord(c) < 128 print(f" Caractère {i}: '{c}' (code {ord(c):3d}) -> ASCII: {est_ascii_char}") |
|
1 2 3 4 5 6 7 8 9 10 11 12 13 |
# Output: # 1. Chaîne vide: True # 2. Caractères de contrôle: '\x00\x07\n\x1b\x7f' -> True # 3. Espaces et tabulations: True # 4. Combinaison avec strip(): True # 5. Non imprimables: '\x00\x01Hello' -> True (mais pas tous imprimables!) # 6. Avec encode(): Test café -> False (identique à isascii()) # # 7. Vérification caractère par caractère: # Caractère 0: 'C' (code 67) -> ASCII: True # Caractère 1: 'a' (code 97) -> ASCII: True # Caractère 2: 'f' (code 102) -> ASCII: True # Caractère 3: 'é' (code 233) -> ASCII: False |
Auteur : Younes Derfoufi
Lieu de travail : CRMEF OUJDA
Site Web : www.tresfacile.net
Chaine YouTube : https://www.youtube.com/user/InformatiquesFacile
Me contacter : https://www.tresfacile.net/me-contacter/
