Maintenant que nous avons appris différentes techniques pour remplacer plusieurs espaces blancs, explorons quelques applications pratiques et comparons leurs performances.
Création d'une fonction utilitaire
Tout d'abord, créons un module utilitaire avec des fonctions qui mettent en œuvre les différentes méthodes de remplacement des espaces blancs que nous avons apprises :
- Dans le WebIDE, créez un nouveau fichier nommé
whitespace_utils.py.
- Ajoutez le code suivant :
import re
import time
def replace_with_split_join(text):
"""Replace multiple whitespaces using the split-join method."""
return ' '.join(text.split())
def replace_with_regex(text):
"""Replace multiple whitespaces using regular expressions."""
return re.sub(r'\s+', ' ', text).strip()
def replace_with_basic(text):
"""Replace multiple whitespaces using basic string methods (less effective)."""
## This is a demonstration of a less effective approach
result = text.strip()
while ' ' in result: ## Keep replacing double spaces until none remain
result = result.replace(' ', ' ')
return result
def time_functions(text, iterations=1000):
"""Compare the execution time of different whitespace replacement functions."""
functions = [
('Split-Join Method', replace_with_split_join),
('Regex Method', replace_with_regex),
('Basic Method', replace_with_basic)
]
results = {}
for name, func in functions:
start_time = time.time()
for _ in range(iterations):
func(text)
end_time = time.time()
results[name] = end_time - start_time
return results
Maintenant, créons un script pour tester nos fonctions utilitaires avec des exemples concrets :
- Créez un nouveau fichier nommé
practical_examples.py.
- Ajoutez le code suivant :
from whitespace_utils import replace_with_split_join, replace_with_regex, time_functions
## Example 1: Cleaning user input
user_input = " Search for: Python programming "
print("Original user input:", repr(user_input))
print("Cleaned user input:", repr(replace_with_split_join(user_input)))
## Example 2: Normalizing addresses
address = """
123 Main
Street, Apt
456, New York,
NY 10001
"""
print("\nOriginal address:")
print(repr(address))
print("Normalized address:")
print(repr(replace_with_regex(address)))
## Example 3: Cleaning CSV data before parsing
csv_data = """
Name, Age, City
John Doe, 30, New York
Jane Smith, 25, Los Angeles
Bob Johnson, 40, Chicago
"""
print("\nOriginal CSV data:")
print(csv_data)
## Clean each line individually to preserve the CSV structure
cleaned_csv = "\n".join(replace_with_split_join(line) for line in csv_data.strip().split("\n"))
print("\nCleaned CSV data:")
print(cleaned_csv)
## Performance comparison
print("\nPerformance Comparison:")
print("Testing with a moderate-sized text sample...")
## Create a larger text sample for performance testing
large_text = (user_input + "\n" + address + "\n" + csv_data) * 100
timing_results = time_functions(large_text)
for method, duration in timing_results.items():
print(f"{method}: {duration:.6f} seconds")
- Exécutez le script :
python3 practical_examples.py
Vous devriez voir une sortie qui inclut les exemples et une comparaison des performances :
Original user input: ' Search for: Python programming '
Cleaned user input: 'Search for: Python programming'
Original address:
'\n123 Main \n Street, Apt \n 456, New York,\n NY 10001\n'
Normalized address:
'123 Main Street, Apt 456, New York, NY 10001'
Original CSV data:
Name, Age, City
John Doe, 30, New York
Jane Smith, 25, Los Angeles
Bob Johnson, 40, Chicago
Cleaned CSV data:
Name, Age, City
John Doe, 30, New York
Jane Smith, 25, Los Angeles
Bob Johnson, 40, Chicago
Performance Comparison:
Testing with a moderate-sized text sample...
Split-Join Method: 0.023148 seconds
Regex Method: 0.026721 seconds
Basic Method: 0.112354 seconds
Les valeurs de chronométrage exactes varieront en fonction de votre système, mais vous devriez remarquer que les méthodes split-join et regex sont significativement plus rapides que l'approche de remplacement de base.
Principaux points à retenir
De notre exploration des techniques de remplacement des espaces blancs, voici les principaux points à retenir :
-
Pour les cas simples : La méthode split-join (' '.join(text.split())) est concise, lisible et efficace.
-
Pour les motifs complexes : Les expressions régulières (re.sub(r'\s+', ' ', text)) offrent plus de flexibilité et de contrôle.
-
La performance est importante : Comme le montre notre test de performance, le choix de la bonne méthode peut avoir un impact significatif sur le temps d'exécution, en particulier pour les tâches de traitement de texte volumineuses.
-
Le contexte est important : Tenez compte des exigences spécifiques de votre tâche de traitement de texte lors du choix d'une approche de remplacement des espaces blancs.
Ces techniques sont des outils précieux pour tout développeur Python travaillant avec des données textuelles, du formatage de chaînes de caractères de base aux tâches avancées de nettoyage et de traitement des données.
