Por qué la búsqueda binaria sigue siendo imprescindible
Cuando una colección crece, recorrerla elemento por elemento deja de ser una opción razonable. Si tienes un millón de registros ordenados y solo necesitas saber dónde está uno, la búsqueda lineal hará, en el peor caso, un millón de comparaciones. La búsqueda binaria resuelve el mismo problema con unas veinte. Esa diferencia, que parece mágica la primera vez que se ve, nace de una idea muy sencilla: si los datos están ordenados, cada comparación permite descartar la mitad de lo que queda.
En este tutorial trabajaremos con Python 3.15, la serie estable más reciente en el momento de escribir estas líneas (la versión final se publicó en octubre de 2026). Todo el código que verás funciona igual en cualquier Python 3.10 o superior, que es la versión a partir de la cual el módulo bisect acepta el parámetro key. No se trata solo de escribir el algoritmo a mano: veremos cómo implementarlo con bucles y con recursión, cómo expresarlo con la biblioteca estándar, qué variantes aparecen en problemas reales (límites inferior y superior, duplicados, rangos, números reales) y cuáles son los errores que más tiempo hacen perder.
Si prefieres empezar por una visión general de los algoritmos de búsqueda y su comparación con el recorrido secuencial, puedes leer antes el artículo sobre algoritmos de búsqueda lineal y binaria en programación. Aquí asumimos que ya conoces los conceptos básicos de listas e índices y nos centramos en el Python moderno y en las variantes que se usan en la práctica.
La idea central y su condición indispensable
La búsqueda binaria mantiene un intervalo de posiciones donde el valor buscado todavía podría estar. Al principio ese intervalo abarca toda la lista. En cada paso se mira el elemento que ocupa el centro: si es el objetivo, hemos terminado; si es menor que el objetivo, todo lo que queda a su izquierda también lo es y se descarta; si es mayor, se descarta la parte derecha. El intervalo se encoge a la mitad en cada iteración hasta que se encuentra el valor o se queda vacío.
La condición que lo hace posible es una sola: los datos deben estar en una lista ya ordenada según el mismo criterio con el que comparas. Si la lista no está ordenada, el algoritmo no avisa de nada; simplemente devuelve resultados incorrectos, y esos fallos silenciosos son los más difíciles de depurar. Más adelante veremos cuándo compensa ordenar primero y cuándo no.
Imagina la lista [3, 8, 12, 19, 23, 31, 40, 52] y que buscas el 31. El centro inicial es el 19, menor que 31, así que te quedas con [23, 31, 40, 52]. El nuevo centro es el 31 (o el 40, según cómo redondees), y en uno o dos pasos lo encuentras. Con ocho elementos hacen falta como mucho cuatro comparaciones; con dieciséis, cinco; con mil millones, treinta. Eso es lo que significa crecer de forma logarítmica, un concepto que puedes repasar en la guía completa sobre notación Big O en algoritmos.
Implementación iterativa paso a paso
La versión con bucle es la más habitual porque no consume pila de llamadas y es fácil de seguir. Necesitamos dos índices que delimitan el intervalo vigente, izq y der, ambos inclusivos, y calculamos el centro en cada vuelta.
def buscar(valores, objetivo):
izq, der = 0, len(valores) - 1
while izq <= der:
medio = izq + (der - izq) // 2
if valores[medio] == objetivo:
return medio
if valores[medio] < objetivo:
izq = medio + 1
else:
der = medio - 1
return -1
temperaturas = [3, 8, 12, 19, 23, 31, 40, 52]
print(buscar(temperaturas, 23))
print(buscar(temperaturas, 5))
4
-1
Hay varios detalles que merecen atención. El primero es la condición izq <= der: como ambos extremos son inclusivos, un intervalo con un solo elemento (izq == der) todavía debe examinarse. Si pusieras <, el último candidato se perdería y la función diría que un valor presente no existe.
El segundo detalle es el cálculo izq + (der - izq) // 2. En lenguajes con enteros de tamaño fijo, sumar izq + der puede desbordar; en Python los enteros no tienen límite, así que (izq + der) // 2 funciona sin problema. Aun así, la forma con resta es un hábito útil si algún día portas el algoritmo a otro lenguaje, y no cuesta nada.
El tercero es que, al descartar la mitad, se mueve el índice a medio + 1 o medio - 1, nunca a medio. Ya hemos comparado ese elemento y sabemos que no es el objetivo; dejarlo dentro del intervalo puede provocar un bucle infinito cuando el intervalo se reduce a dos elementos.
Para ver el recorrido real, mira cómo evoluciona la búsqueda del 23 en la lista anterior. Primero izq=0, der=7 y medio=3; el valor 19 es menor, así que izq pasa a 4. Después medio=5; el 31 es mayor, así que der pasa a 4. Finalmente medio=4 y aparece el 23. Tres comparaciones en lugar de cinco.
Versión recursiva y su coste oculto
La misma lógica se puede expresar con una función que se llama a sí misma sobre un intervalo más pequeño. Su caso base es el intervalo vacío, que significa que el valor no está.
def buscar_rec(valores, objetivo, izq=0, der=None):
if der is None:
der = len(valores) - 1
if izq > der:
return -1
medio = izq + (der - izq) // 2
if valores[medio] == objetivo:
return medio
if valores[medio] < objetivo:
return buscar_rec(valores, objetivo, medio + 1, der)
return buscar_rec(valores, objetivo, izq, medio - 1)
codigos = [101, 205, 307, 411, 520, 633]
print(buscar_rec(codigos, 411))
print(buscar_rec(codigos, 999))
3
-1
Observa que pasamos los índices y no una porción de la lista. Es tentador escribir buscar_rec(valores[medio + 1:], objetivo), y a primera vista parece más limpio, pero cada rebanada copia la mitad de la lista. Eso convierte un algoritmo logarítmico en uno lineal, porque la copia cuesta tiempo proporcional al tamaño. Además, el índice devuelto ya no correspondería a la lista original y tendrías que ir sumando desplazamientos. Pasar índices evita ambos problemas.
En cuanto a la profundidad, Python limita la recursión (por defecto a unos mil niveles), pero la búsqueda binaria solo necesita unas treinta llamadas para cubrir mil millones de elementos, de modo que no hay riesgo real. La razón para preferir el bucle es más bien práctica: evita el coste de las llamadas y es más fácil de modificar cuando se necesitan variantes.
Entender el invariante para no equivocarse
Los errores de uno de más o de menos, los famosos off-by-one, desaparecen cuando razonas con un invariante del bucle: una frase que es verdadera antes y después de cada iteración. En nuestra versión iterativa, el invariante es: si el objetivo está en la lista, su posición está dentro de [izq, der]. Cada rama del bucle debe preservarlo.
Comprobémoslo. Si valores[medio] < objetivo, el objetivo no puede estar en medio ni a su izquierda, así que el nuevo intervalo [medio + 1, der] sigue conteniéndolo. Si es mayor, ocurre lo simétrico. Cuando el intervalo queda vacío (izq > der), el invariante implica que el objetivo no existe. Si en algún momento no puedes justificar una rama con esta frase, ahí está tu error.
Esta forma de pensar es especialmente útil para las variantes que veremos a continuación, donde el intervalo se define de otra manera (por ejemplo, semiabierto) y donde cambiar un <= por un < altera el significado completo del algoritmo.
Duplicados: límite inferior y límite superior
En el mundo real las listas rara vez tienen valores únicos. Si buscas el 20 en [10, 20, 20, 20, 35, 50], la función anterior podría devolver cualquiera de las tres posiciones, y normalmente lo que necesitas es una concreta: la primera, la última o la cantidad total de repeticiones. Para eso existen dos variantes clásicas.
El límite inferior (lower bound) es la primera posición en la que se podría insertar el objetivo manteniendo el orden, es decir, el índice del primer elemento que no es menor que él. El límite superior (upper bound) es el índice del primer elemento estrictamente mayor. Con un intervalo semiabierto [izq, der) el código es muy compacto.
def limite_inferior(valores, objetivo):
izq, der = 0, len(valores)
while izq < der:
medio = (izq + der) // 2
if valores[medio] < objetivo:
izq = medio + 1
else:
der = medio
return izq
def limite_superior(valores, objetivo):
izq, der = 0, len(valores)
while izq < der:
medio = (izq + der) // 2
if valores[medio] <= objetivo:
izq = medio + 1
else:
der = medio
return izq
pedidos = [10, 20, 20, 20, 35, 50]
inicio = limite_inferior(pedidos, 20)
fin = limite_superior(pedidos, 20)
print(inicio, fin, fin - inicio)
1 4 3
Fíjate en las diferencias con la versión clásica. Aquí der empieza en len(valores), no en len(valores) - 1, porque el intervalo es semiabierto y la posición final es una respuesta válida (insertar al final). El bucle usa izq < der, y cuando el centro no sirve se hace der = medio en lugar de medio - 1. Es otro invariante: la respuesta siempre está en [izq, der]. La única diferencia entre ambas funciones es < frente a <=, y es exactamente esa diferencia la que decide si los iguales quedan a la izquierda o a la derecha.
Con estas dos funciones se obtiene casi todo: la primera aparición (inicio, comprobando que el valor allí es el objetivo), la última (fin - 1) y el recuento (fin - inicio) en tiempo logarítmico, algo que con una búsqueda lineal costaría recorrer toda la lista.
El módulo bisect: la herramienta que ya tienes
Todo lo anterior está implementado, probado y escrito en C dentro de la biblioteca estándar. El módulo bisect ofrece bisect_left (equivalente a nuestro límite inferior), bisect_right (equivalente al superior, con el alias bisect) e insort_left e insort_right, que insertan manteniendo el orden.
from bisect import bisect_left, bisect_right, insort
pedidos = [10, 20, 20, 20, 35, 50]
print(bisect_left(pedidos, 20))
print(bisect_right(pedidos, 20))
print(bisect_left(pedidos, 25))
insort(pedidos, 25)
print(pedidos)
1
4
4
[10, 20, 20, 20, 25, 35, 50]
Para convertir esto en una función de búsqueda exacta, el patrón habitual es calcular la posición y comprobar que el elemento en ella coincide:
from bisect import bisect_left
def indice_exacto(valores, objetivo):
pos = bisect_left(valores, objetivo)
if pos < len(valores) and valores[pos] == objetivo:
return pos
return -1
print(indice_exacto([2, 4, 6, 8], 6))
print(indice_exacto([2, 4, 6, 8], 7))
2
-1
La comprobación pos < len(valores) no es decorativa: si el objetivo es mayor que todos los elementos, bisect_left devuelve len(valores), y acceder a ese índice lanzaría IndexError. Es el fallo más frecuente al usar este patrón por primera vez.
Una advertencia sobre insort: encontrar la posición cuesta tiempo logarítmico, pero insertar en una lista desplaza los elementos posteriores, y eso es lineal. Para cargas de inserciones masivas con consultas ocasionales suele ser aceptable; para millones de inserciones intercaladas con lecturas, una estructura distinta (un montículo, un árbol equilibrado o una biblioteca de contenedores ordenados) puede ser mejor.
Buscar por clave: registros y objetos
Desde Python 3.10, todas las funciones de bisect aceptan el argumento key, igual que sorted o min. Antes había que mantener una lista paralela con las claves o envolver los elementos en tuplas; ahora basta con indicar cómo extraer el valor comparable.
from bisect import bisect_left
empleados = [
("ana", 1200),
("luis", 1500),
("sara", 1800),
("marta", 2400),
]
pos = bisect_left(empleados, 1800, key=lambda e: e[1])
print(pos, empleados[pos])
2 ('sara', 1800)
Hay una sutileza que sorprende: la función key se aplica a los elementos de la lista, pero no al valor que buscas. Por eso pasamos 1800 y no una tupla completa. Y, como siempre, la lista debe estar ordenada por esa misma clave; si está ordenada por nombre y buscas por sueldo, el resultado carece de sentido.
También funciona con dataclasses o cualquier objeto: key=lambda p: p.precio bastará. Si ordenas con sorted(productos, key=lambda p: p.precio) y buscas con la misma clave, ambas operaciones se mantienen coherentes. Si quieres repasar las opciones de ordenación, tienes el artículo sobre cómo ordenar listas en Python con sort().
Búsqueda por tramos: tablas de rangos
Un uso muy elegante de bisect_right es sustituir largas cadenas de if/elif que clasifican un número según umbrales. Los puntos de corte forman una lista ordenada y la posición devuelta es directamente el índice de la categoría.
from bisect import bisect_right
umbrales = [60, 70, 80, 90]
letras = "FDCBA"
def calificacion(puntos):
return letras[bisect_right(umbrales, puntos)]
print(calificacion(59), calificacion(85), calificacion(90))
F B A
Usamos bisect_right porque queremos que un 90 exacto caiga en la categoría superior: el límite derecho coloca los iguales a la izquierda del punto de inserción, de modo que el 90 queda ya “pasado” y el índice resultante es 4. Con bisect_left, el 90 pertenecería a la categoría B. Elegir entre ambas es decidir a qué lado pertenece el borde, algo que conviene documentar.
Este patrón es útil para tramos de impuestos, escalas de precios por volumen, clasificación de latencias en percentiles o cualquier tabla de intervalos. Es más corto, más rápido y menos propenso a errores que la cadena condicional equivalente.
Buscar sobre una respuesta y no sobre una lista
La generalización más potente de la técnica es darse cuenta de que no hace falta una lista. Basta con tener un espacio de valores posibles y un predicado monótono: falso para valores pequeños y verdadero a partir de cierto punto (o al revés). La búsqueda binaria encuentra la frontera sin recorrer el espacio completo. Esto se llama búsqueda binaria sobre la respuesta.
Supón que debes descargar varios lotes de datos, con tamaños [25, 10, 18, 6, 14] en megabytes, y que cada hora solo puedes procesar un lote a una velocidad fija de v megabytes por hora (si un lote es menor que v, igualmente gasta la hora completa). Tienes un máximo de 6 horas. ¿Cuál es la velocidad mínima entera que lo permite?
def horas_necesarias(cargas, velocidad):
return sum(-(-c // velocidad) for c in cargas)
def velocidad_minima(cargas, horas):
izq, der = 1, max(cargas)
while izq < der:
medio = (izq + der) // 2
if horas_necesarias(cargas, medio) <= horas:
der = medio
else:
izq = medio + 1
return izq
print(velocidad_minima([25, 10, 18, 6, 14], 6))
18
La expresión -(-c // velocidad) es un redondeo hacia arriba con enteros que evita importar math. La monotonía está clara: cuanto mayor es la velocidad, menos horas se necesitan, así que si una velocidad sirve, cualquiera mayor también. El espacio de búsqueda va de 1 a la carga máxima, porque más rápido que el lote mayor no aporta nada. Con velocidad 18 las horas son 2+1+1+1+1 = 6, y con 17 serían 7.
Este tipo de razonamiento aparece en problemas de capacidad, planificación y optimización: el tamaño mínimo de un búfer, el número mínimo de servidores para cumplir un SLA, el tiempo mínimo para terminar un conjunto de tareas. Siempre que puedas comprobar “¿esto basta?” con un coste razonable y la respuesta cambie una sola vez de no a sí, la técnica se aplica.
Números reales y tolerancia
La búsqueda binaria también sirve para encontrar ceros de funciones continuas o raíces, siempre que se acote un intervalo donde el signo cambie. Con números en coma flotante no se puede esperar igualdad exacta, así que se detiene cuando el intervalo es suficientemente pequeño.
def raiz_cuadrada(n, tolerancia=1e-9):
bajo, alto = 0.0, max(1.0, n)
while alto - bajo > tolerancia:
medio = (bajo + alto) / 2
if medio * medio < n:
bajo = medio
else:
alto = medio
return (bajo + alto) / 2
print(round(raiz_cuadrada(2), 6))
print(round(raiz_cuadrada(0.25), 6))
1.414214
0.5
El max(1.0, n) es necesario porque para valores menores que 1 la raíz es mayor que el número, y un límite superior igual a n dejaría la solución fuera del intervalo. En la práctica, para raíces usarías math.sqrt, pero el esquema es el mismo que se emplea para invertir funciones monótonas, calibrar parámetros o buscar umbrales en simulaciones.
Si la tolerancia es demasiado pequeña respecto a la precisión de los números, el bucle puede no terminar nunca porque el punto medio deja de cambiar. Una alternativa robusta es limitar el número de iteraciones (por ejemplo, 100 es de sobra para un float).
Rendimiento: cuándo gana y cuándo no
La búsqueda binaria hace O(log n) comparaciones, pero eso no significa que siempre sea la mejor opción. Hay tres preguntas que conviene hacerse antes de usarla.
La primera es si los datos ya están ordenados o si se pueden mantener ordenados. Ordenar una lista cuesta O(n log n); si solo vas a hacer una consulta, la búsqueda lineal de O(n) sale ganando. Si vas a hacer muchas consultas, ordenar una sola vez y reutilizar el resultado amortiza el coste enseguida. Un orden aproximado de magnitud: a partir de unas decenas de consultas sobre miles de elementos, ya compensa.
La segunda es si una estructura de acceso directo resuelve el problema mejor. Para pertenencia o búsqueda exacta por clave, un set o un dict ofrecen coste medio constante. La búsqueda binaria brilla cuando necesitas relaciones de orden: el elemento más cercano, el siguiente mayor, el anterior menor, un rango, un percentil. Un diccionario no puede responder “¿cuál es el primer pedido posterior a esta fecha?”, y bisect sí.
La tercera es el tamaño. Para listas de pocas decenas de elementos, la diferencia es imperceptible, y la solución más simple suele ser la mejor. Si quieres medirlo, timeit te permite comparar con tus propios datos:
import timeit
from bisect import bisect_left
datos = list(range(0, 2_000_000, 2))
objetivo = 1_999_998
lineal = timeit.timeit(lambda: datos.index(objetivo), number=20)
binaria = timeit.timeit(lambda: bisect_left(datos, objetivo), number=20)
print(f"index: {lineal:.4f} s")
print(f"bisect: {binaria:.6f} s")
No incluyo los resultados porque dependen de tu máquina, pero la diferencia será de varios órdenes de magnitud a favor de bisect en este caso extremo, con el objetivo situado al final. Ejecútalo con distintos tamaños y posiciones para comprobar cómo cambia la proporción. Para ampliar sobre complejidades, la guía de complejidad de tiempo en Big O ayuda a interpretar estas medidas.
Errores frecuentes y cómo detectarlos
Estos son los fallos que más se repiten al escribir o usar búsquedas binarias, junto con la forma de evitarlos.
Buscar en datos sin ordenar. Es el más grave porque no produce excepción. Si la lista procede de una fuente externa, valida el orden en pruebas (all(a <= b for a, b in zip(v, v[1:]))) o ordénala al cargarla. Y recuerda que el orden debe coincidir con el criterio de comparación: ordenar cadenas sin distinguir mayúsculas y buscar con comparación normal produce resultados erróneos.
Bucles infinitos. Se dan cuando el intervalo no se reduce: por ejemplo, con izq = medio en un esquema de límites inclusivos. Revisa que cada rama avance al menos una posición, y recuerda el invariante.
Condición de parada incorrecta. Mezclar intervalos inclusivos con semiabiertos es la fuente número uno de errores. Elige un estilo por función y no lo cambies a mitad de código.
Olvidar la comprobación final con bisect. Como vimos, bisect_left devuelve un punto de inserción, no una confirmación de existencia. Comprueba el rango y la igualdad.
Comparar tipos incompatibles. Una lista que mezcla enteros y cadenas no se puede ordenar ni buscar en Python 3; lanzará TypeError. Normaliza los datos antes.
Valores especiales en coma flotante. float("nan") no es comparable con nada, ni siquiera consigo mismo, y rompe cualquier orden. Si tus datos pueden contenerlo, fíltralo antes.
Modificar la lista mientras se busca. En programas concurrentes, otro hilo puede insertar o eliminar elementos entre el cálculo del índice y su uso. Protege la sección con un cerrojo o trabaja sobre una copia.
Cómo probar tu implementación con confianza
Dado que bisect es una referencia fiable, puedes verificar tus funciones comparándolas con ella sobre miles de listas aleatorias. Este tipo de prueba por contraste detecta los errores de borde que los ejemplos manuales dejan pasar.
import random
from bisect import bisect_left, bisect_right
def comprobar(n_pruebas=5000):
for _ in range(n_pruebas):
tam = random.randint(0, 12)
valores = sorted(random.randint(0, 10) for _ in range(tam))
objetivo = random.randint(-1, 11)
assert limite_inferior(valores, objetivo) == bisect_left(valores, objetivo), (valores, objetivo)
assert limite_superior(valores, objetivo) == bisect_right(valores, objetivo), (valores, objetivo)
print("todo correcto")
comprobar()
todo correcto
Las listas pequeñas con valores repetidos y objetivos fuera de rango son precisamente las que generan los casos límite: lista vacía, un solo elemento, objetivo menor que todos, mayor que todos, y duplicados en los extremos. Al usar tamaños de 0 a 12 y valores de 0 a 10, el azar cubre todos ellos con facilidad. Si prefieres un enfoque más sistemático, la biblioteca hypothesis genera casos y reduce automáticamente el ejemplo que falla.
Una buena práctica adicional es dejar estas comprobaciones como pruebas automáticas en tu proyecto, de forma que cualquier refactorización futura se valide al instante.
Aplicaciones reales de las variantes
Para cerrar el recorrido técnico, conviene ver dónde aparecen estas ideas fuera de los ejercicios.
Los registros de eventos ordenados por marca de tiempo permiten extraer una ventana (por ejemplo, las entradas entre las 10:00 y las 10:05) con dos llamadas a bisect, sin recorrer el archivo completo. El mismo principio se emplea en índices de bases de datos, que son estructuras ordenadas donde se localiza el primer valor de un rango y se avanza desde allí.
En control de versiones, la búsqueda binaria localiza la confirmación que introdujo un fallo: se marca una versión buena y otra mala, y cada prueba descarta la mitad de las intermedias. Es la misma técnica, aplicada sobre historial en lugar de sobre una lista.
En sistemas de precios o de facturación, las tablas por tramos se resuelven con la técnica de umbrales que vimos antes. En juegos y gráficos, se usa para localizar en qué segmento de una animación o curva cae un instante concreto. En autocompletado, el límite inferior de un prefijo en una lista de palabras ordenadas da el comienzo del rango de sugerencias.
Y en pruebas de rendimiento, la búsqueda sobre la respuesta permite encontrar el máximo de peticiones por segundo que un servicio soporta antes de superar un límite de latencia: se prueba una carga, se observa si cumple, y se acota el rango hasta converger.
Buenas prácticas para código mantenible
Prefiere bisect cuando la tarea encaje: es más corto, está optimizado y cualquier lector de Python lo reconoce. Reserva la implementación manual para variantes que la biblioteca no cubre, como la búsqueda sobre una respuesta o sobre estructuras que no son listas.
Documenta el significado de los índices que devuelves. Una función que retorna -1 para “no encontrado” es cómoda pero fácil de malinterpretar, porque -1 es también un índice válido en Python (el último elemento). Si lo prefieres, devuelve None o lanza una excepción propia, de modo que un olvido no pase desapercibido.
Añade anotaciones de tipo. Con tipos genéricos puedes indicar que la función trabaja con cualquier secuencia de elementos comparables, lo que ayuda a los analizadores estáticos:
from collections.abc import Sequence
from typing import Protocol, TypeVar
class Comparable(Protocol):
def __lt__(self, otro, /) -> bool: ...
T = TypeVar("T", bound=Comparable)
def buscar_tipada(valores: Sequence[T], objetivo: T) -> int | None:
izq, der = 0, len(valores)
while izq < der:
medio = (izq + der) // 2
if valores[medio] < objetivo:
izq = medio + 1
else:
der = medio
if izq < len(valores) and not (objetivo < valores[izq]):
return izq
return None
Esta versión solo usa el operador <, que es lo mínimo que exige el protocolo, y detecta la igualdad con not (objetivo < valores[izq]) una vez que sabemos que valores[izq] no es menor. Es el mismo criterio que usa la biblioteca estándar y facilita que tu función funcione con tipos propios que solo definen __lt__.
Por último, separa la lógica de búsqueda de la de presentación o entrada de datos: una función pura que recibe una secuencia y un objetivo es trivial de probar y de reutilizar.
Conclusiones
La búsqueda binaria es una de esas ideas pequeñas con un impacto enorme: descartar la mitad de las posibilidades en cada paso convierte problemas enormes en trabajos de unas pocas decenas de comparaciones. Pero su potencia viene acompañada de exigencias: datos ordenados con el mismo criterio de comparación, un invariante claro y cuidado con los bordes.
Has visto la versión iterativa y la recursiva, las variantes de límite inferior y superior para manejar duplicados, el módulo bisect con su parámetro key para registros y tablas de tramos, y la generalización a espacios de respuesta y números reales. También has repasado cuándo conviene ordenar primero, cuándo es mejor un set o un dict, y cómo probar tus implementaciones contra la biblioteca estándar.
Como siguiente paso, toma una lista de datos propios (fechas, precios, versiones) y resuelve con bisect una pregunta de rango que hasta ahora respondías con un bucle. Después intenta plantear un problema de capacidad como una búsqueda sobre la respuesta. Si además quieres reforzar la base, revisa el artículo sobre algoritmos de búsqueda lineal y binaria y practica con las dos formas de implementarla hasta que el invariante te resulte natural.
