¿Te gustaría aprender Python desde cero?
Tenemos los cursos que necesitas.¡Haz clic aquí!



Tenemos una lista (Lista A) que contiene 2 millones de ID de los clientes que reciben un determinado servicio, por otro lado tenemos una lista (Lista B) que contiene 850,000 ID de clientes que han realizado el pago de su servicio del mes de Abril. Se necesita saber cuales son los ID de clientes que aún no han pagado su servicio.

Solución

La solución parece resultar simple, debemos de saber que IDs de la Lista A no están en la Lista B. Si bien el algoritmo parece tener todo el sentido del mundo, es importante emplear las funciones y herramientas correctas en la codificación.

Vamos a resolver este problema con 3 alternativas distintas (métodos getDifferent1, getDifferent2 y getDifferent3). El contenido de las listas se generarán de manera aleatoria y de manera secuencial. Finalmente el script mostrará en pantalla los tiempos de ejecución de las 3 alternativas.

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
“””
Clase que permite generar dos listas de elementos y devuelve los tiempos de ejecución de las
distintas maneras de calcular la diferencia de elementos de ambas listas.
“””
__author__ = ‘Nombre y Apellido’
import os, sys
import time
import random

class OperationList():
list_a = []
list_b = []
result = []
random_generate = None

def __init__(self, random_generate):
self.random_generate = True if int(random_generate)==1 else False
print (“\n Generacion de elementos aleatorios: ” + str(“On” if self.random_generate==True else “Off”))

def createListA(self, items):
“””
Método que crea la primera lista de elementos (números)
“””
print (“\nCreando lista A….”, end=””)
sys.stdout.flush()
if self.random_generate == True:
self.list_a = set([random.randint(1, int(items)*2) for _ in range(int(items))])
else:
self.list_a = set(x for x in range(0, int(items)))
print (“OK (“+ str(len(self.list_a)) +” elementos)”)
sys.stdout.flush()

def createListB(self, items):
“””
Método que crea la segunda lista de elementos (números)
“””
if int(items) <= len(self.list_a):
print (“Creando lista B….”, end=””)
sys.stdout.flush()
if self.random_generate == True:
self.list_b = random.sample(set(self.list_a), int(items))
else:
self.list_b = set(x for x in range(0, int(items)))
print (“OK (“+ str(len(self.list_b)) +” elementos)”)
else:
raise AttributeError(“El numero de elementos de la lista B debe ser menor que ” + str(len(self.list_a)))

def getDifferent1(self):
“””
Primer método para hallar la diferencia de elementos entre la lista A y B
“””
return set(a for a in self.list_a if a not in self.list_b)

def getDifferent2(self):
“””
Segundo método para hallar la diferencia de elementos entre la lista A y B
“””
n_list_b = set(self.list_b)
return set(a for a in self.list_a if a not in n_list_b)

def getDifferent3(self):
“””
Tercer método para hallar la diferencia de elementos entre la lista A y B
“””
return set(self.list_a) – set(self.list_b)

def calculate(self):
“””
Método para calcular los tiempos de ejecución de cada función.
“””
operations = [self.getDifferent1, self.getDifferent2, self.getDifferent3]
self.result = {f.__name__:[] for f in operations}
for f in operations:
time_start = time.time()
f()
time_finish = time.time()
#Almacenamos la cantidad de segundos de ejecución de cada método
self.result[f.__name__].append(time_finish – time_start)

def printListA(self):
“””
Método que muestra en pantalla el contenido de la Lista 1 (A)
“””
print (self.list_a)

def printListB(self):
“””
Método que muestra en pantalla el contenido de la Lista 2 (B)
“””
print (self.list_b)
print (len(self.list_b))

def showTimeProcess(self):
“””
Método que muestra en pantalla los resultados
“””
print (“\nTiempos de Ejecucion”)
print (“——————————————————————–“)
sys.stdout.flush()
for f in sorted(self.result):
sys.stdout.flush()
print (“Metodo ” + f +” : ” + str(sum(self.result[f])/len(self.result[f])) + ” segundos”)
sys.stdout.flush()

if __name__ == ‘__main__’:
try:
“””
Las cantidades de elementos que debe tener cada lista se envia por argumentos en la
invocación del script por consola.
Primer argumento: Cantidad de elementos Lista A
Segundo argumento: Cantidad de elementos Lista B
Tercer argumento: Valor númerico donde
1 = Generar elementos de lista de forma aleatoria
0 = No generar elementos de lista de forma aleatoria
Ejem: $>py TimeExecutionList.py 400000 3000 0
“””
obj = OperationList(sys.argv[3])
obj.createListA(sys.argv[1])
obj.createListB(sys.argv[2])
obj.calculate()
obj.showTimeProcess()
except AttributeError as ex:
print (ex)
except IndexError as ex:
print (ex)
except ValueError as ex:
print (ex)

 

Ejecución

$> git clone https://github.com/gchacaltana/PythonToolkit.git
$> cd PythonToolkit
$> py TimeExecutionList.py 2000000 850000 0
$> py TimeExecutionList.py 500000 2000 1

Resultado

El resultado obtenido de la ejecución del script es el siguiente:

Ejercicio 1: No generando aleatoriamente los elementos de las listas A y B.

 

Ejercicio 2: Generando aleatoriamente los elementos de las listas A y B.

 

Te esperamos en los próximos artículos en donde hablaremos mas acerca de estos temas que hoy en día son de importancia e interés en el mundo de la tecnología.

¿Te gustaría aprender Python desde cero?
Tenemos los cursos que necesitas.¡Haz clic aquí!
About Author

NGuerrero

0 0 votos
Article Rating
Suscribir
Notificar de
guest
0 Comments
Comentarios.
Ver todos los comentarios
0
¿Te gusta este articulo? por favor comentax
()
x
Abrir chat
¿Quieres aprender a programar?
Hola 👋,
¿Te interesa información de nuestros cursos?