Iterar sobre un conjunto en Python

En Python, Set es una colección desordenada de tipos de datos que es iterable, mutable y no tiene elementos duplicados.
Existen numerosas formas que se pueden usar para iterar sobre un Conjunto. Algunas de estas formas proporcionan una ejecución de tiempo más rápida en comparación con otras. Algunas de estas formas incluyen iterar usando bucles for/while, comprensiones, iteradores y sus variaciones. Veamos todas las diferentes formas en que podemos iterar sobre un conjunto en Python.
Análisis de cada método: 
Para explicar el funcionamiento de cada forma/técnica, se ha calculado el tiempo por conjunto (conjunto generado aleatoriamente) 5 veces para obtener una estimación aproximada de cuánto tiempo lleva cada técnica para iterar sobre un conjunto determinado. Se agregó random.seed(21) a cada script para fijarse en los números aleatorios que se generan cada vez que se ejecuta el programa. El uso de semillas constantes nos ayuda a determinar qué técnica es mejor para un determinado conjunto generado aleatoriamente.
Método n.º 1: iterar sobre un conjunto usando un bucle for simple.
 

# Creating a set using string
test_set = set("geEks")
 
# Iterating using for loop
for val in test_set:
    print(val)

Producción:

k
s
e
g
E

Análisis: 
 

# importing libraries
from timeit import default_timer as timer
import itertools
import random
 
# Function under evaluation
def test_func(test_set):
 
    for val in test_set:
        _ = val
 
# Driver function
if __name__ == '__main__':
 
    random.seed(21)
 
    for _ in range(5):
        test_set = set()
 
        # generating a set of random numbers
        for el in range(int(1e6)):
            el = random.random()
            test_set.add(el)
 
        start = timer()
        test_func(test_set)
        end = timer()
 
        print(str(end - start))

Producción: 
 

0.06303901899809716
0.06756918999963091
0.06692574200133095
0.067220498000097
0.06748137499744189

 
Método n.º 2: iterar sobre un conjunto usando el bucle for enumerado.
 

# Creating a set using string
test_set = set("geEks")
 
# Iterating using enumerated for loop
for id,val in enumerate(test_set):
    print(id, val)

Producción: 
 

0 E
1 e
2 k
3 g
4 s

Análisis: 
 

# importing libraries
from timeit import default_timer as timer
import itertools
import random
 
# Function under evaluation
def test_func(test_set):
 
    for id, val in enumerate(test_set):
        _ = val
 
# Driver function
if __name__ == '__main__':
 
    random.seed(21)
    for _ in range(5):
        test_set = set()
 
        # generating a set of random numbers
        for el in range(int(1e6)):
            el = random.random()
            test_set.add(el)
 
        start = timer()
        test_func(test_set)
        end = timer()
 
        print(str(end - start))

Salida : 
 

0.1306622320007591
0.13657568199778325
0.13797824799985392
0.1386374360008631
0.1424286179972114

  
Método #3: iterar sobre un conjunto como lista indexada. 
 

# Creating a set using string
test_set = set("geEks")
 
test_list = list(test_set)
 
# Iterating over a set as a indexed list
for id in range(len(test_list)):
        print(test_list[id])

Producción: 
 

g
k
E
s
e

Análisis: 
 

# importing libraries
from timeit import default_timer as timer
import itertools
import random
 
# Function under evaluation
def test_func(test_set):
 
    test_list = list(test_set)
 
    for id in range(len(test_list)):
        _ = test_list[id]
 
# Driver function
if __name__ == '__main__':
 
    random.seed(21)
    for _ in range(5):
        test_set = set()
 
        # generating a set of random numbers
        for el in range(int(1e6)):
            el = random.random()
            test_set.add(el)
 
        start = timer()
        test_func(test_set)
        end = timer()
 
        print(str(end - start))

Salida : 
 

0.20036015100049553
0.2557020290005312
0.4601482660000329
0.2161413249996258
0.18769703499856405

  
Método #4: iterar sobre un conjunto usando comprensión y constructor/inicializador de lista.
 

# Creating a set using string
test_set = set("geEks")
 
# Iterating using list-comprehension
com = list(val for val in test_set)
print(*com)

Producción: 
 

k s e g E

Análisis: 
 

# importing libraries
from timeit import default_timer as timer
import itertools
import random
 
# Function under evaluation
def test_func(test_set):
 
    list(val for val in test_set)
 
# Driver function
if __name__ == '__main__':
 
    random.seed(21)
    for _ in range(5):
        test_set = set()
 
        # generating a set of random numbers
        for el in range(int(1e6)):
            el = random.random()
            test_set.add(el)
 
        start = timer()
        test_func(test_set)
        end = timer()
 
        print(str(end - start))

Salida : 
 

0.1662169310002355
0.1783527520019561
0.21661155100082397
0.19131610199838178
0.19931397800246486

  
Método #5: iterar sobre un conjunto usando comprensión. 
 

# Creating a set using string
test_set = set("geEks")
 
# Iterating using list-comprehension
com = [print(val) for val in test_set]

Producción:

e
E
g
s
k

Análisis: 
 

# importing libraries
from timeit import default_timer as timer
import itertools
import random
 
# Function under evaluation
def test_func(test_set):
 
    [val for val in test_set]
 
# Driver function
if __name__ == '__main__':
 
    random.seed(21)
    for _ in range(5):
        test_set = set()
 
        # generating a set of random numbers
        for el in range(int(1e6)):
            el = random.random()
            test_set.add(el)
 
        start = timer()
        test_func(test_set)
        end = timer()
 
        print(str(end - start))

Salida : 
 

0.11386321299869451
0.111869686999853
0.1092844699996931
0.11223735699968529
0.10928539399901638

  
Método n.º 6: iterar sobre un conjunto usando mapas, lambda y comprensión de listas 
 

# importing libraries
from timeit import default_timer as timer
import itertools
import random
 
# Function under evaluation
def test_func(test_set):
 
    [map(lambda val: val, test_set)]
 
# Driver function
if __name__ == '__main__':
 
    random.seed(21)
    for _ in range(5):
        test_set = set()
 
        # generating a set of random numbers
        for el in range(int(1e6)):
            el = random.random()
            test_set.add(el)
 
        start = timer()
        test_func(test_set)
        end = timer()
 
        print(str(end - start))

Salida : 
 

1.0756000847322866e-05
1.310199877480045e-05
1.269100175704807e-05
1.1588999768719077e-05
1.2522999895736575e-05

  
Método #7: iterar sobre un conjunto usando iterador. 
 

# importing libraries
from timeit import default_timer as timer
import itertools
import random
 
# Function under evaluation
def test_func(test_set):
 
    for val in iter(test_set):
        _ = val
 
# Driver function
if __name__ == '__main__':
 
    random.seed(21)
    for _ in range(5):
        test_set = set()
 
        # generating a set of random numbers
        for el in range(int(1e6)):
            el = random.random()
            test_set.add(el)
 
        start = timer()
        test_func(test_set)
        end = timer()
 
        print(str(end - start))

Salida : 
 

0.0676155920009478
0.07111633900058223
0.06994135700006154
0.0732101009998587
0.08668379899972933

 
Método #8: iterar sobre un conjunto usando iterador y ciclo while.
 

# Creating a set using string
test_set = set("geEks")
 
iter_gen = iter(test_set)
 
while True:
    try:
        # get the next item
        print(next(iter_gen))
         
        ''' do something with element '''
         
    except StopIteration:
        # if StopIteration is raised,
        # break from loop
        break

Producción: 

E
s
e
k
g

Análisis: 
 

# importing libraries
from timeit import default_timer as timer
import itertools
import random
 
# Function under evaluation
def test_func(test_set):
 
    iter_gen = iter(test_set)
    while True:
        try:
            # get the next item
            next(iter_gen)
            # do something with element
        except StopIteration:
            # if StopIteration is raised, break from loop
            break
 
# Driver function
if __name__ == '__main__':
 
    random.seed(21)
    for _ in range(5):
        test_set = set()
 
        # generating a set of random numbers
        for el in range(int(1e6)):
            el = random.random()
            test_set.add(el)
 
        start = timer()
        test_func(test_set)
        end = timer()
 
        print(str(end - start))

Producción: 
 

0.2136418699992646
0.1952157889973023
0.4234208280031453
0.255840524998348
0.24712910099697183

Conclusión: 
entre todas las técnicas de creación de bucles, la iteración simple para bucles y la creación de bucles sobre iteradores funcionan mejor, mientras que comparando todas las técnicas, usar map with lambda over set o iterator of set funciona mejor, dando un rendimiento de un millón de iteraciones establecidas en menos de 10 milisegundos. Es bastante notable que los ejemplos anteriores solo tienen un acceso único a los componentes del conjunto por iteración, mientras que si aumentamos la cantidad de veces que se accede a un componente del conjunto por iteración, puede cambiar el tiempo necesario para la iteración.
Nota: Los valores mencionados anteriormente en el resultado del ejemplo pueden variar. La razón detrás de la variación del consumo de tiempo es la dependencia de la máquina del poder de procesamiento del procesador del sistema del individuo.