Construyendo una función de búsqueda sin distinción entre mayúsculas y minúsculas
Ahora que has aprendido diferentes métodos para la comparación sin distinción entre mayúsculas y minúsculas (case-insensitive comparison), construyamos una función de búsqueda práctica que pueda encontrar palabras en un texto sin importar el formato de mayúsculas y minúsculas.
Creando una función de búsqueda
- En el WebIDE, crea un nuevo archivo y llámalo
search_function.py.
- Agrega el siguiente código para implementar una simple función de búsqueda sin distinción entre mayúsculas y minúsculas:
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}'")
- Guarda el archivo y ejecútalo con:
python3 search_function.py
Deberías ver una salida como esta:
Found 'python' at 3 positions: [1, 67, 132]
Matches in context:
...[Python] is a pro...
...ctively.
[python] is easy ...
...ers love [PYTHON] for its ...
Esto muestra que nuestra función encontró "Python" en tres lugares, sin importar si estaba escrito como "Python", "python" o "PYTHON". La función también muestra cada coincidencia en su contexto original, preservando la capitalización original.
Mejorando la función de búsqueda
Mejoremos nuestra función para hacerla más útil agregando la opción de contar palabras y manejar la coincidencia de palabras completas:
Agrega el siguiente código a tu archivo 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}")
Ejecuta el script nuevamente:
python3 search_function.py
Ahora deberías ver una salida adicional:
Total occurrences of 'python' (including within words): 4
Whole word occurrences of 'python': 3
Esto muestra que "python" aparece 4 veces en total, pero solo 3 veces como palabra completa (una aparición está en "python-script", que no es una coincidencia de palabra completa).
Probando diferentes escenarios
Agreguemos una prueba más para mostrar cómo nuestras funciones manejan diferentes tipos de texto:
## 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}")
Agrega este código y ejecuta el script nuevamente:
python3 search_function.py
Verás un desglose detallado de cómo la función maneja diferentes escenarios de texto:
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
Esto demuestra cómo se puede usar la comparación sin distinción entre mayúsculas y minúsculas en una función de búsqueda del mundo real, con opciones para manejar diferentes requisitos de búsqueda.
En el siguiente paso, aplicaremos estas técnicas para crear una aplicación práctica de validación de entrada de usuario.
