Création d'une fonction de recherche insensible à la casse
Maintenant que vous avez appris différentes méthodes de comparaison insensible à la casse, créons une fonction de recherche pratique qui peut trouver des mots dans un texte indépendamment de la casse.
Création d'une fonction de recherche
- Dans l'WebIDE, créez un nouveau fichier et nommez-le
search_function.py.
- Ajoutez le code suivant pour implémenter une simple fonction de recherche insensible à la casse :
def search_text(query, text):
"""
Search for a query in text, ignoring case.
Returns a list of all matching positions.
"""
## Convert both to lowercase for case-insensitive comparison
query_lower = query.lower()
text_lower = text.lower()
found_positions = []
position = 0
## Find all occurrences
while position < len(text_lower):
position = text_lower.find(query_lower, position)
if position == -1: ## No more matches
break
found_positions.append(position)
position += 1 ## Move to the next character
return found_positions
## Example text
sample_text = """
Python is a programming language that lets you work quickly and integrate systems effectively.
python is easy to learn, powerful, and versatile.
Many developers love PYTHON for its simplicity and readability.
"""
## Test search
search_query = "python"
results = search_text(search_query, sample_text)
## Display results
if results:
print(f"Found '{search_query}' at {len(results)} positions: {results}")
## Show each match in context
print("\nMatches in context:")
for pos in results:
## Get some context around the match (10 characters before and after)
start = max(0, pos - 10)
end = min(len(sample_text), pos + len(search_query) + 10)
context = sample_text[start:end]
## Highlight the match by showing the original case from the text
match_original_case = sample_text[pos:pos+len(search_query)]
print(f"...{context.replace(match_original_case, f'[{match_original_case}]')}...")
else:
print(f"No matches found for '{search_query}'")
- Enregistrez le fichier et exécutez-le avec :
python3 search_function.py
Vous devriez voir une sortie comme celle-ci :
Found 'python' at 3 positions: [1, 67, 132]
Matches in context:
...[Python] is a pro...
...ctively.
[python] is easy ...
...ers love [PYTHON] for its ...
Cela montre que notre fonction a trouvé "Python" à trois endroits, indépendamment de si elle était écrite comme "Python", "python" ou "PYTHON". La fonction montre également chaque correspondance dans son contexte d'origine, en préservant la capitalisation d'origine.
Amélioration de la fonction de recherche
Améliorons notre fonction pour la rendre plus utile en ajoutant l'option de compter les mots et de gérer les correspondances de mots entiers :
Ajoutez le code suivant à votre fichier search_function.py :
def count_word_occurrences(word, text, whole_word=False):
"""
Count occurrences of a word in text, ignoring case.
If whole_word=True, only count complete word matches.
"""
word_lower = word.lower()
text_lower = text.lower()
if whole_word:
## Use word boundaries to match whole words only
import re
pattern = r'\b' + re.escape(word_lower) + r'\b'
matches = re.findall(pattern, text_lower)
return len(matches)
else:
## Simple substring counting
return text_lower.count(word_lower)
## Test the enhanced function
test_text = """
Python is great. I love python programming.
This python-script demonstrates case-insensitive searching.
The word "python" appears multiple times as a whole word and as part of other words.
"""
## Count all occurrences (including within words)
count_all = count_word_occurrences("python", test_text)
print(f"Total occurrences of 'python' (including within words): {count_all}")
## Count only whole word occurrences
count_whole = count_word_occurrences("python", test_text, whole_word=True)
print(f"Whole word occurrences of 'python': {count_whole}")
Exécutez le script à nouveau :
python3 search_function.py
Vous devriez maintenant voir une sortie supplémentaire :
Total occurrences of 'python' (including within words): 4
Whole word occurrences of 'python': 3
Cela montre que "python" apparaît 4 fois au total, mais seulement 3 fois comme mot entier (une occurrence est dans "python-script" qui n'est pas une correspondance de mot entier).
Test de différents scénarios
Ajoutons un autre test pour montrer comment nos fonctions gèrent différents types de texte :
## Add more test cases
test_cases = [
("Python programming is fun", "python", "Simple sentence with one occurrence"),
("Python, python, PYTHON!", "python", "Multiple occurrences with different cases"),
("No matches here", "python", "No matches"),
("Python-script and PythonProgram contain python", "python", "Mixed word boundaries")
]
print("\nTesting different scenarios:")
for text, search_word, description in test_cases:
whole_matches = count_word_occurrences(search_word, text, whole_word=True)
all_matches = count_word_occurrences(search_word, text)
print(f"\nScenario: {description}")
print(f"Text: '{text}'")
print(f" - Whole word matches: {whole_matches}")
print(f" - All matches: {all_matches}")
Ajoutez ce code et exécutez le script à nouveau :
python3 search_function.py
Vous verrez un détail de la façon dont la fonction gère différents scénarios de texte :
Testing different scenarios:
Scenario: Simple sentence with one occurrence
Text: 'Python programming is fun'
- Whole word matches: 1
- All matches: 1
Scenario: Multiple occurrences with different cases
Text: 'Python, python, PYTHON!'
- Whole word matches: 3
- All matches: 3
Scenario: No matches
Text: 'No matches here'
- Whole word matches: 0
- All matches: 0
Scenario: Mixed word boundaries
Text: 'Python-script and PythonProgram contain python'
- Whole word matches: 1
- All matches: 3
Cela démontre comment la comparaison insensible à la casse peut être utilisée dans une fonction de recherche du monde réel, avec des options pour gérer différentes exigences de recherche.
Dans l'étape suivante, nous appliquerons ces techniques pour créer une application pratique de validation d'entrée utilisateur.
