1. A propos de numpy.char
Le module numpy.char est un sous-module de NumPy spécialisé dans les opérations sur les chaînes de caractères pour les tableaux NumPy. Contrairement aux opérations de chaînes standards de Python qui fonctionnent sur des chaînes individuelles, numpy.char permet d'appliquer des opérations de manipulation de texte de manière vectorisée sur des tableaux entiers de chaînes de caractères. Ce module est particulièrement utile pour le traitement de données textuelles à grande échelle.
2. Création de tableaux de chaînes de caractères
Avant d'utiliser les fonctions de numpy.char, il faut d'abord créer des tableaux de chaînes de caractères. NumPy utilise le type de données dtype='U' pour les chaînes Unicode.
|
1 2 3 4 5 6 7 8 9 10 11 12 |
import numpy as np # Création d'un tableau de chaînes de caractères arr = np.array(['bonjour', 'le', 'monde', 'python'], dtype='U') print("Tableau original:") print(arr) print("Type de données:", arr.dtype) # Tableau 2D de chaînes arr_2d = np.array([['numpy', 'pandas'], ['scipy', 'matplotlib']], dtype='U') print("\nTableau 2D:") print(arr_2d) |
Sortie:
|
1 2 3 4 5 6 7 |
Tableau original: ['bonjour' 'le' 'monde' 'python'] Type de données: <U7 Tableau 2D: [['numpy' 'pandas'] ['scipy' 'matplotlib']] |
3. Opérations de manipulation de base
3.1 Concaténation de chaînes
La fonction numpy.char.add() permet de concaténer des chaînes élément par élément entre deux tableaux de même dimension.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
import numpy as np # Tableaux de chaînes arr1 = np.array(['hello', 'data', 'machine'], dtype='U') arr2 = np.array([' world', ' science', ' learning'], dtype='U') # Concaténation élément par élément result = np.char.add(arr1, arr2) print("Concaténation:") print(result) # Concaténation avec une chaîne constante greetings = np.char.add('Hi ', arr1) print("\nAvec constante:") print(greetings) |
Sortie:
|
1 2 3 4 5 |
Concaténation: ['hello world' 'data science' 'machine learning'] Avec constante: ['Hi hello' 'Hi data' 'Hi machine'] |
3.2 Modification de la casse
Les fonctions upper(), lower(), capitalize() et title() permettent de modifier la casse des chaînes dans un tableau.
|
1 2 3 4 5 6 7 8 9 |
import numpy as np arr = np.array(['numpy', 'CHAR', 'Module', 'tutoriel'], dtype='U') print("Original:", arr) print("Majuscules:", np.char.upper(arr)) print("Minuscules:", np.char.lower(arr)) print("Capitalisé:", np.char.capitalize(arr)) print("Titre:", np.char.title(arr)) |
Sortie:
|
1 2 3 4 5 |
Original: ['numpy' 'CHAR' 'Module' 'tutoriel'] Majuscules: ['NUMPY' 'CHAR' 'MODULE' 'TUTORIEL'] Minuscules: ['numpy' 'char' 'module' 'tutoriel'] Capitalisé: ['Numpy' 'Char' 'Module' 'Tutoriel'] Titre: ['Numpy' 'Char' 'Module' 'Tutoriel'] |
4. Recherche et remplacement
4.1 Recherche de sous-chaînes
Les fonctions find() et count() permettent de localiser et compter les occurrences de sous-chaînes.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 |
import numpy as np arr = np.array(['programmation', 'programme', 'gramme', 'grammaire'], dtype='U') # Recherche de la sous-chaîne 'gram' positions = np.char.find(arr, 'gram') print("Positions de 'gram':", positions) # Compter les occurrences de 'mm' counts = np.char.count(arr, 'mm') print("Occurrences de 'mm':", counts) # Vérifier le début et la fin des chaînes start_with_pro = np.char.startswith(arr, 'pro') print("Commence par 'pro':", start_with_pro) end_with_re = np.char.endswith(arr, 're') print("Termine par 're':", end_with_re) |
Sortie:
|
1 2 3 4 |
Positions de 'gram': [ 3 4 0 1] Occurrences de 'mm': [1 2 2 1] Commence par 'pro': [ True True False False] Termine par 're': [False False False True] |
4.2 Remplacement de texte
La fonction replace() permet de remplacer des sous-chaînes par d'autres dans tout le tableau.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 |
import numpy as np arr = np.array(['hello_world', 'test_function', 'data_science'], dtype='U') # Remplacer les underscores par des espaces result = np.char.replace(arr, '_', ' ') print("Après remplacement:") print(result) # Remplacer plusieurs occurrences arr2 = np.array(['aaabbbccc', 'bbbaaaccc'], dtype='U') result2 = np.char.replace(arr2, 'aaa', 'XXX') print("\nRemplacement multiple:") print(result2) |
Sortie:
|
1 2 3 4 5 |
Après remplacement: ['hello world' 'test function' 'data science'] Remplacement multiple: ['aaabbbccc' 'bbbXXXccc'] |
5. Division et jointure de chaînes
5.1 Division de chaînes
La fonction split() permet de diviser les chaînes selon un séparateur spécifié.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
import numpy as np arr = np.array(['python,numpy,pandas', 'java,spring,hibernate', 'js,react,node'], dtype='U') # Division par virgule split_result = np.char.split(arr, ',') print("Division par virgule:") for i, item in enumerate(split_result): print(f"Élément {i}: {item}") # Division avec limite arr2 = np.array(['a:b:c:d:e', '1-2-3-4-5'], dtype='U') split_limit = np.char.split(arr2, [':', '-']) print("\nDivision avec séparateurs différents:") print(split_limit) |
Sortie:
|
1 2 3 4 5 6 7 |
Division par virgule: Élément 0: ['python', 'numpy', 'pandas'] Élément 1: ['java', 'spring', 'hibernate'] Élément 2: ['js', 'react', 'node'] Division avec séparateurs différents: [list(['a', 'b', 'c', 'd', 'e']) list(['1', '2', '3', '4', '5'])] |
5.2 Jointure de chaînes
La fonction join() permet de joindre des séquences de caractères ou des tableaux de chaînes.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 |
import numpy as np # Joindre des caractères avec un séparateur separator = np.array(['-', ':', '|'], dtype='U') sequences = np.array([['a', 'b', 'c'], ['1', '2', '3'], ['x', 'y', 'z']], dtype='U') result = np.char.join(separator[:, np.newaxis], sequences) print("Résultat de la jointure:") print(result) # Jointure simple simple_join = np.char.join('-', 'ABCD') print("\nJointure simple:") print(simple_join) |
Sortie:
|
1 2 3 4 5 6 7 |
Résultat de la jointure: [['a-b-c' 'a:b:c' 'a|b|c'] ['1-2-3' '1:2:3' '1|2|3'] ['x-y-z' 'x:y:z' 'x|y|z']] Jointure simple: A-B-C-D |
6. Fonctions avancées et cas d'utilisation
6.1 Formatage de chaînes
La fonction numpy.char.mod() permet d'appliquer un formatage de type printf à un tableau de chaînes.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 |
import numpy as np # Formatage avec placeholders template = np.array(['%s a %d ans', 'Note: %.2f/20', 'Code: %s-%04d'], dtype='U') values = [('Pierre', 25), (18.5,), ('ABC', 42)] result = np.char.mod(template, *values) print("Résultat du formatage:") print(result) # Formatage avec plusieurs valeurs templates = np.array(['Nom: %s, Age: %d', 'Ville: %s, Code: %s'], dtype='U') data = [('Alice', 30), ('Paris', '75000')] formatted = np.char.mod(templates, *zip(*data)) print("\nFormatage multiple:") print(formatted) |
Sortie:
|
1 2 3 4 5 |
Résultat du formatage: ['Pierre a 25 ans' 'Note: 18.50/20' 'Code: ABC-0042'] Formatage multiple: ['Nom: Alice, Age: 30' 'Ville: Paris, Code: 75000'] |
6.2 Nettoyage et manipulation d'espaces
Les fonctions strip(), lstrip() et rstrip() permettent de supprimer les espaces ou caractères spécifiques.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 |
import numpy as np arr = np.array([' python ', ' numpy ', ' pandas ', ' scipy '], dtype='U') print("Original:", arr) print("Strip complet:", np.char.strip(arr)) print("Strip gauche:", np.char.lstrip(arr)) print("Strip droit:", np.char.rstrip(arr)) # Strip de caractères spécifiques arr2 = np.array(['***python***', '###numpy###', '+++pandas+++'], dtype='U') stripped = np.char.strip(arr2, '*#+') print("\nStrip personnalisé:", stripped) |
Sortie:
|
1 2 3 4 5 6 |
Original: [' python ' ' numpy ' ' pandas ' ' scipy '] Strip complet: ['python' 'numpy' 'pandas' 'scipy'] Strip gauche: ['python ' 'numpy ' 'pandas ' 'scipy '] Strip droit: [' python' ' numpy' ' pandas' ' scipy'] Strip personnalisé: ['python' 'numpy' 'pandas'] |
6.3 Comparaison de chaînes
Les fonctions de comparaison permettent de comparer des tableaux de chaînes élément par élément.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 |
import numpy as np arr1 = np.array(['python', 'java', 'c++', 'javascript'], dtype='U') arr2 = np.array(['python', 'Java', 'c++', 'JavaScript'], dtype='U') print("Égalité (case sensitive):", np.char.equal(arr1, arr2)) print("Égalité (ignore case):", np.char.equal(np.char.lower(arr1), np.char.lower(arr2))) print("Comparaison (greater):", np.char.greater(arr1, arr2)) print("Comparaison (less):", np.char.less(arr1, arr2)) # Recherche d'éléments contenant une sous-chaîne contains_java = np.char.find(arr1, 'java') >= 0 print("\nContient 'java':", contains_java) |
Sortie:
|
1 2 3 4 5 6 |
Égalité (case sensitive): [ True False True False] Égalité (ignore case): [ True False True False] Comparaison (greater): [False True False True] Comparaison (less): [False False False False] Contient 'java': [False True False True] |
Younes Derfoufi
CRMEF OUJDA
