Cursos Empresas Blog Live Conf Eventos Precios

0:009:55

Recursos

Resumen

¿Cómo medir el tiempo de ejecución de algoritmos en Python?

Medir el tiempo de ejecución de nuestros algoritmos es crucial para optimizar su rendimiento. Esto puede hacerse fácilmente en Python mediante el uso de bibliotecas específicas para manejar el tiempo. Te explicaré detalladamente cómo realizar estas mediciones y notarás la importancia de entender el crecimiento de los algoritmos.

¿Qué herramientas podemos usar en Python?

Para medir el tiempo de ejecución en Python, utilizamos la biblioteca datetime. Con esta herramienta, podemos:

Medir el tiempo al inicio de la ejecución de la función.
Finalizar la medición al terminar la ejecución.

Ejemplo de código para medir el tiempo de ejecución

from datetime import datetime

# Medir el tiempo al inicio
tiempo_inicial = datetime.now()

# Aquí llamamos la función que queremos medir
mi_funcion()

# Medir el tiempo al final
tiempo_final = datetime.now()

# Calcular la diferencia de tiempo
tiempo_ejecucion = tiempo_final - tiempo_inicial
print(tiempo_ejecucion)

¿Qué consideración debemos tener con datasets grandes?

Cuando trabajamos con grandes volúmenes de datos, como el dataset de 5,000 valores mencionado, es importante saber que:

No se deben copiar y pegar grandes datasets directamente en el código. Es mejor importarlos usando librerías como Pandas o NumPy.
Estas prácticas permiten procesar datos de forma más eficiente.

¿Qué diferencias existen entre Selection Sort y Bubble Sort?

Al ejecutar ambos algoritmos con grandes dataset, obtenemos resultados distintos en cuanto a tiempo:

Selection Sort: Generalmente es más eficiente ya que no ejecuta ciclos innecesarios; su enfoque es encontrar un elemento y regresarlo inmediatamente.
Bubble Sort: realiza iteraciones por cada elemento del array, lo cual incrementa la complejidad.

Ambos algoritmos tienen una complejidad de O(n^2), lo que significa que su eficiencia disminuye de manera exponencial con el aumento de datos. Sin embargo, en implementación, el Selection Sort logra un mejor rendimiento debido a su lógica más simple.

¿Por qué el tiempo de ejecución no siempre es el mejor indicador?

El tiempo de ejecución depende de:

Carga de la computadora: Otros programas pueden estar utilizando recursos, afectando así el resultado.
Consistencia: Incluso ejecutando el mismo algoritmo bajo las mismas condiciones pueden existir variaciones en el tiempo.

Es crucial enfocar la optimización en la complejidad del algoritmo más que en el tiempo de ejecución. Una función matemática indica si un algoritmo tiene muchos ciclos anidados, característica que afecta directamente el rendimiento.

Con estos conocimientos, ya tienes las bases para evaluar y mejorar la eficiencia de tus algoritmos en Python. Continúa aprendiendo y perfeccionando tus habilidades, ¡el mundo de la programación está lleno de posibilidades!

Comparación de Tiempos de Ejecución en Algoritmos de Ordenamiento

Curso de Introducción a los Algoritmos de Ordenamiento

Clase 9 / 10

Ver clases

Comparación de Tiempos de Ejecución en Algoritmos de Ordenamiento

Curso de Introducción a los Algoritmos de Ordenamiento

Clase 9 de 10

Clase 9 / 10

Comparación de Tiempos de Ejecución en Algoritmos de Ordenamiento

Curso de Introducción a los Algoritmos de Ordenamiento

Clase 9 / 10

Ver clases

from datetime import datetime # Medir el tiempo al inicio tiempo_inicial = datetime.now() # Aquí llamamos la función que queremos medir mi_funcion() # Medir el tiempo al final tiempo_final = datetime.now() # Calcular la diferencia de tiempo tiempo_ejecucion = tiempo_final - tiempo_inicial print(tiempo_ejecucion)

Comentarios

Iván Arcos#2108697

Este es el comportamiento de los algoritmos de ordenamiento en una imagen :D

Edwin Jesset Barrientos Gonzales#1034334

La notación Big-O nos proporciona una manera de saber cómo se va a comportar un algoritmo en función de los argumentos que le pasemos y la escala de los mismos.

Royer Guerrero Pinilla#1031315

Quería mostrar un gif de la velocidad de los algoritmos pero no fue posible team platzi deberían mejorar eso 😥😥😥, de todas formas les dejo el link Velocidad de algoritmos de ordenamiento

Orlando Javier Javier Rosas#1412551

Estos métodos son de orden O(n^2) y no exponenciales

Jesús Petrona Castro#1367778

Si se analiza a detalle ambos códigos nos daremos cuenta que tanto el Bubble Sort como el Selection Sort tienen casi la misma estructura de código, dos for anidados con un if dentro del segundo for, ahora bien, ambos algoritmos van ordenando el set en cada recorrido, ejemplo: si se ordena de menor a mayor en el caso del Bubble Sort los extremos derechos ya se consideran ordenados (números mayores) y ya no los analiza, y para el Selection sort el extremo izquierdo se considera ordenado y también ya no se analizan, la gran diferencia entre cada uno de ellos es que el Bubble Sort realiza muchos más cambios o swap entre cada recorrido y el Selection Sort sólo realiza uno en cada recorrido del set.

import random, timeit
from bokeh.plotting import figure, output_file, show

def selectionSort(array):
    for i in range(len(array)):
        auxIndex = i
        for j in range(i + 1, len(array)):
            if array[auxIndex] > array[j]:
                auxIndex = j
        array[i], array[auxIndex] = array[auxIndex], array[i]
    return array

def bubbleSort(array):
    n = len(array)
    for i in range(n):
        for j in range(0, n - i - 1):
            if array[j] > array[j + 1]:
                array[j], array[j + 1] = array[j + 1], array[j]
    return array

def createValues(size):
    return [random.randint(0, size) for i in range(size)]

def createLoop(limit):
    loopLimit = limit
    baseSize = 100
    values = []
    times = {}
    for i in range(0, loopLimit):
        values = createValues(baseSize)
        startTime = timeit.default_timer()
        bubbleSort(values.copy())
        stopTime = timeit.default_timer()
        finalTime = stopTime - startTime
        times[f'B={baseSize}'] = finalTime

        startTime = timeit.default_timer()
        selectionSort(values.copy())
        stopTime = timeit.default_timer()
        finalTime = stopTime - startTime
        times[f'S={baseSize}'] = finalTime

        baseSize *= 10
    return times

def createColumnsPlot(values):
    x_vals = []
    y_vals = []
    for d in values:
        x_vals.append(f'{d}')
        y_vals.append(values[d])
    output_file('comparing_plot.html')
    fig = figure(x_range=x_vals, plot_height=350, title="Time comparing: Bubble Sort VS Selection Sort", toolbar_location=None, tools="")
    fig.vbar(x=x_vals, top=y_vals, width=0.9)
    fig.y_range.start = 0
    show(fig)

if __name__ == "__main__":
    data = createLoop(3)
    createColumnsPlot(data)

import java.util.Arrays;

//1. Buscar el número menor en mi array
//2. Crear dos subArrays para llevar el control de mi algoritmo
//3. Imprimir el resultado del ordenamiento.
public class SelectionSort {

    //Ciclo que recorre todo el array y busca el valor mínimo
    static void selectionSort(int[] numeros){
        int n = numeros.length;
        for (int i = 0; i < n-1; i++) {
            int numMenor=i;
            for (int j = i+1; j < n; j++) {
                if (numeros[numMenor] > numeros[j]){
                    numMenor=j;
                }
            }
            int temp = numeros[i];
            numeros[i] = numeros[numMenor];
            numeros[numMenor] = temp;
            System.out.println("El Array como está quedando es: " + Arrays.toString(numeros));
        }
    }

    public static void main(String[] args) {
        int[] numeros = {20, 5, 21, 6, 23, 7, 34, 999, 68};
        selectionSort(numeros);
        System.out.println("El array ordenado es: " + Arrays.toString(numeros));
    }

}

import SelectionSort,BubbleSort,datetime

#dejare la lista con pocos valores aquí en el aporte de la clase por fines practicos

lista=[2385,1853,5145,1102,5432,7367,3396,7513,3260,2428,3521,11663,2697,3102,3857]

tiempoInicial = datetime.datetime.now()
BubbleSort.bubbleSort(lista)
print(datetime.datetime.now()-tiempoInicial, "fue el tiempo para Bubble Sort")

tiempoInicial = datetime.datetime.now()
SelectionSort.selectionSort(lista)
print(datetime.datetime.now()-tiempoInicial, "fue el tiempo para Selection Sort")

## Este es un programa que ordena elementos mediante el algoritmo SelectionSort 
import sys

def SelectionSort(array):
    #recorremos nuestro array
    for i in range(len(array)):
        #Encontrar el valor minimo restante dentro de nuestro array desordenado
        idxDes = i
        print(array)
        for j in range(i+1, len(array)):
            if array[idxDes] > array[j]:
                idxDes = j      

        array[i], array[idxDes] = array[idxDes], array[i]       

    #Encontramos el minimo, vamos a moverlo al subarray arreglado
array = [64, 25, 12, 22, 11]
SelectionSort(array)
print ("Sorted array") 
for i in range(len(array)): 
    print("%d" %array[i]),  


<code> 

Comentarios

Iván Arcos#2108697

Este es el comportamiento de los algoritmos de ordenamiento en una imagen :D

Edwin Jesset Barrientos Gonzales#1034334

La notación Big-O nos proporciona una manera de saber cómo se va a comportar un algoritmo en función de los argumentos que le pasemos y la escala de los mismos.

Royer Guerrero Pinilla#1031315

Quería mostrar un gif de la velocidad de los algoritmos pero no fue posible team platzi deberían mejorar eso 😥😥😥, de todas formas les dejo el link Velocidad de algoritmos de ordenamiento

Orlando Javier Javier Rosas#1412551

Estos métodos son de orden O(n^2) y no exponenciales

Jesús Petrona Castro#1367778

import random, timeit
from bokeh.plotting import figure, output_file, show

def selectionSort(array):
    for i in range(len(array)):
        auxIndex = i
        for j in range(i + 1, len(array)):
            if array[auxIndex] > array[j]:
                auxIndex = j
        array[i], array[auxIndex] = array[auxIndex], array[i]
    return array

def bubbleSort(array):
    n = len(array)
    for i in range(n):
        for j in range(0, n - i - 1):
            if array[j] > array[j + 1]:
                array[j], array[j + 1] = array[j + 1], array[j]
    return array

def createValues(size):
    return [random.randint(0, size) for i in range(size)]

def createLoop(limit):
    loopLimit = limit
    baseSize = 100
    values = []
    times = {}
    for i in range(0, loopLimit):
        values = createValues(baseSize)
        startTime = timeit.default_timer()
        bubbleSort(values.copy())
        stopTime = timeit.default_timer()
        finalTime = stopTime - startTime
        times[f'B={baseSize}'] = finalTime

        startTime = timeit.default_timer()
        selectionSort(values.copy())
        stopTime = timeit.default_timer()
        finalTime = stopTime - startTime
        times[f'S={baseSize}'] = finalTime

        baseSize *= 10
    return times

def createColumnsPlot(values):
    x_vals = []
    y_vals = []
    for d in values:
        x_vals.append(f'{d}')
        y_vals.append(values[d])
    output_file('comparing_plot.html')
    fig = figure(x_range=x_vals, plot_height=350, title="Time comparing: Bubble Sort VS Selection Sort", toolbar_location=None, tools="")
    fig.vbar(x=x_vals, top=y_vals, width=0.9)
    fig.y_range.start = 0
    show(fig)

if __name__ == "__main__":
    data = createLoop(3)
    createColumnsPlot(data)

import java.util.Arrays;

//1. Buscar el número menor en mi array
//2. Crear dos subArrays para llevar el control de mi algoritmo
//3. Imprimir el resultado del ordenamiento.
public class SelectionSort {

    //Ciclo que recorre todo el array y busca el valor mínimo
    static void selectionSort(int[] numeros){
        int n = numeros.length;
        for (int i = 0; i < n-1; i++) {
            int numMenor=i;
            for (int j = i+1; j < n; j++) {
                if (numeros[numMenor] > numeros[j]){
                    numMenor=j;
                }
            }
            int temp = numeros[i];
            numeros[i] = numeros[numMenor];
            numeros[numMenor] = temp;
            System.out.println("El Array como está quedando es: " + Arrays.toString(numeros));
        }
    }

    public static void main(String[] args) {
        int[] numeros = {20, 5, 21, 6, 23, 7, 34, 999, 68};
        selectionSort(numeros);
        System.out.println("El array ordenado es: " + Arrays.toString(numeros));
    }

}

import SelectionSort,BubbleSort,datetime

#dejare la lista con pocos valores aquí en el aporte de la clase por fines practicos

lista=[2385,1853,5145,1102,5432,7367,3396,7513,3260,2428,3521,11663,2697,3102,3857]

tiempoInicial = datetime.datetime.now()
BubbleSort.bubbleSort(lista)
print(datetime.datetime.now()-tiempoInicial, "fue el tiempo para Bubble Sort")

tiempoInicial = datetime.datetime.now()
SelectionSort.selectionSort(lista)
print(datetime.datetime.now()-tiempoInicial, "fue el tiempo para Selection Sort")

## Este es un programa que ordena elementos mediante el algoritmo SelectionSort 
import sys

def SelectionSort(array):
    #recorremos nuestro array
    for i in range(len(array)):
        #Encontrar el valor minimo restante dentro de nuestro array desordenado
        idxDes = i
        print(array)
        for j in range(i+1, len(array)):
            if array[idxDes] > array[j]:
                idxDes = j      

        array[i], array[idxDes] = array[idxDes], array[i]       

    #Encontramos el minimo, vamos a moverlo al subarray arreglado
array = [64, 25, 12, 22, 11]
SelectionSort(array)
print ("Sorted array") 
for i in range(len(array)): 
    print("%d" %array[i]),  


<code> 

import random, timeit from bokeh.plotting import figure, output_file, show def selectionSort(array): for i in range(len(array)): auxIndex = i for j in range(i + 1, len(array)): if array[auxIndex] > array[j]: auxIndex = j array[i], array[auxIndex] = array[auxIndex], array[i] return array def bubbleSort(array): n = len(array) for i in range(n): for j in range(0, n - i - 1): if array[j] > array[j + 1]: array[j], array[j + 1] = array[j + 1], array[j] return array def createValues(size): return [random.randint(0, size) for i in range(size)] def createLoop(limit): loopLimit = limit baseSize = 100 values = [] times = {} for i in range(0, loopLimit): values = createValues(baseSize) startTime = timeit.default_timer() bubbleSort(values.copy()) stopTime = timeit.default_timer() finalTime = stopTime - startTime times[f'B={baseSize}'] = finalTime startTime = timeit.default_timer() selectionSort(values.copy()) stopTime = timeit.default_timer() finalTime = stopTime - startTime times[f'S={baseSize}'] = finalTime baseSize *= 10 return times def createColumnsPlot(values): x_vals = [] y_vals = [] for d in values: x_vals.append(f'{d}') y_vals.append(values[d]) output_file('comparing_plot.html') fig = figure(x_range=x_vals, plot_height=350, title="Time comparing: Bubble Sort VS Selection Sort", toolbar_location=None, tools="") fig.vbar(x=x_vals, top=y_vals, width=0.9) fig.y_range.start = 0 show(fig) if __name__ == "__main__": data = createLoop(3) createColumnsPlot(data)

Comentarios (43)43 comentarios

Iván Arcos

Hace 6 años

Kenyi Julberht Hancco Quispe

Se suponía que Selection era más rápido que Bubble :O

Leonardo Galindo

Hace 4 años

Segun mis pruebas el Selection Sort es mas rapido que el Bubble Sort con diferencia. . . .

. . . Ordenando un array de 25.000 numeros

Edwin Jesset Barrientos Gonzales

Hace 7 años

Royer Guerrero Pinilla

Elisa Zamarron Muñoz

Es interesante, porque en ese GIF parece que gana BubbleSort.

Jaime Escobedo Vargas

https://ibb.co/Pj9y76N

Orlando Javier Javier Rosas

Cristian Blandon

"Polinomiales"

Rubén Cuello

Hace 5 años

Gracias. Me estaba molestando escuchar tan seguido la palabra "exponencial"

Jesús Petrona Castro

Otra diferencia sin duda, es que si el set de números ya está ordenado o semi-ordenado, el Selection Sort va a realizar todos los ciclo sin excepción, y en cambio para el Bubble Sort se puede implementar la verificación y saber si el set ya está ordenado y romper los ciclos y así terminar el algoritmo.

Se puede decir que depende del objetivo y uso que se le quiera dar, pero en definitiva ambos algoritmos son malos para ordenar set de números muy grandes.

Saludos.

Juan Camilo Noreña López

Hace 2 años

Hola Jesús!

Tanto en buble sort como en selection sort se puede implementar la logica para que cuando este ordenado se haga un break y deje de ejecutar el ciclo.

Gerson Montenegro

Obtuve esta comparación luego de testar con 100, 1000, y 10000 valores a ordenar en cada oportunidad. Me pareció genial lo rápido que es Selection Sort, a pesar de que también usa un segundo ciclo.

Aquí el código

Nahim Terrazas Parada

Que basura de curso, pense que iban a ensenhar algoritmos como QuickSort o MergeSort, decepcionado totalmente

Juan Carlos Ortiz Romero

El Bubble Sort como el Selection Sort tienen casi la misma estructura de código, dos for anidados con un if dentro del segundo for, ahora bien, ambos algoritmos van ordenando el set en cada recorrido, ejemplo: si se ordena de menor a mayor en el caso del Bubble Sort los extremos derechos ya se consideran ordenados (números mayores) y ya no los analiza, y para el Selection sort el extremo izquierdo se considera ordenado y también ya no se analizan, la gran diferencia entre cada uno de ellos es que el Bubble Sort realiza muchos más cambios o swap entre cada recorrido y el Selection Sort sólo realiza uno en cada recorrido del set. Otra diferencia sin duda, es que si el set de números ya está ordenado o semi-ordenado, el Selection Sort va a realizar todos los ciclo sin excepción, y en cambio para el Bubble Sort se puede implementar la verificación y saber si el set ya está ordenado y romper los ciclos y así terminar el algoritmo.

Hanier Morales

Investigacion bien chingona guardado cuatro y media am.docx xD jajajaja crack!!

marco antonio

es verdad le toma el doble de tiempo

Michael Ballesteros

En java:

Joel Dominguez Merino

Interesante el tiempo que les toma a cada algoritmo ordenarlos.

German Tellez Vanegas

¿Por qué se coloca una coma al final?

Rafael Pardo Rodriguez

Hola German, es que parte del codigo preguntas sobre la coma?

A lo mejor la prone al final de algunas partes, por ejemplo cuando termine unos parentesis. (), Algo asi, si preguntas por eso, esta mal, pudo haberse equivocado.

Javier Daza

Yo también me pregunto lo mismo. El por qué de la coma al final del último for

José manuel Sanchez Juarez

Creo que el profesor todo lo ase todo a fuerza bruta todos los lenguajes de programación puede generar número aleatorio de una forma sencilla.

Duban Andres Guzman Higuita

Por un momento pensé que mi laptop estaba pidiendo auxilio corriendo los programas jaja

Para que se usa "%d" % ? si ejecuto el codigo con o sin esto, me da el mismo resultado

Nicolas Alpargatero

Hace 3 años

Con el filtro en bubble de parar cuando quede ordenado, queda más rápido que el selection sort.

Ian Yared Oliva Hernández

Para visualizar en la misma terminal los resultados y sin tener que alterar los scripts previamente realizados, hice otro script importando los dos scripts realizados previamente.

El resultado se ve de la siguiente manera:

Pablo Eduardo Diaz Hernandez

Jhon Freddy Tavera Blandon

Los dos algoritmos tienen un crecimiento del tipo, exponencial y este crecimiento, pese a que los dos son poco eficientes porque estamos enfocados en algoritmos muy simples

Recursos

Resumen

Comparación de Tiempos de Ejecución en Algoritmos de Ordenamiento

Comparación de Tiempos de Ejecución en Algoritmos de Ordenamiento

Comparación de Tiempos de Ejecución en Algoritmos de Ordenamiento

Progreso del curso

Introducción

Bubble Sort

Selection Sort

Cierre

Comparación de Tiempos de Ejecución en Algoritmos de Ordenamiento

Comparación de Tiempos de Ejecución en Algoritmos de Ordenamiento

Recursos

Resumen

¿Cómo medir el tiempo de ejecución de algoritmos en Python?

¿Qué herramientas podemos usar en Python?

Ejemplo de código para medir el tiempo de ejecución

¿Qué consideración debemos tener con datasets grandes?

¿Qué diferencias existen entre Selection Sort y Bubble Sort?

¿Por qué el tiempo de ejecución no siempre es el mejor indicador?

Comentarios

Recursos

Resumen

¿Cómo medir el tiempo de ejecución de algoritmos en Python?

¿Qué herramientas podemos usar en Python?

Ejemplo de código para medir el tiempo de ejecución

¿Qué consideración debemos tener con datasets grandes?

¿Qué diferencias existen entre Selection Sort y Bubble Sort?

¿Por qué el tiempo de ejecución no siempre es el mejor indicador?

Comentarios