¿Cómo puedo crear una lista de elementos a partir de un iterador (convertir el iterador en una lista)?

Dado un iterador user_iterator¿cómo puedo iterar sobre el iterador una lista de los objetos producidos?

Tengo este código, que parece funcionar:

user_list = [user for user in user_iterator]

Pero, ¿hay algo más rápido, mejor o más correcto?

list(your_iterator)

desde pitón 3.5 puedes usar * operador de desempaquetado iterable:

user_list = [*your_iterator]

pero la forma pitónica de hacerlo es:

user_list  = list(your_iterator)

@Robino estaba sugiriendo agregar algunas pruebas que tienen sentido, por lo que aquí hay un punto de referencia simple entre 3 formas posibles (quizás las más utilizadas) para convertir un iterador en una lista:

1. por tipo constructor

   list(my_iterator)

2. al desempacar

   [*my_iterator]

3. usando la comprensión de listas

   [e for e in my_iterator]

he estado usando simple_bechmark biblioteca:

from simple_benchmark import BenchmarkBuilder
from heapq import nsmallest

b = BenchmarkBuilder()

@b.add_function()
def convert_by_type_constructor(size):
    list(iter(range(size)))

@b.add_function()
def convert_by_list_comprehension(size):
    [e for e in iter(range(size))]

@b.add_function()
def convert_by_unpacking(size):
    [*iter(range(size))]


@b.add_arguments('Convert an iterator to a list')
def argument_provider():
    for exp in range(2, 22):
        size = 2**exp
        yield size, size

r = b.run()
r.plot()

Como puede ver, es muy difícil hacer una diferencia entre la conversión por el constructor y la conversión por desempaquetado, la conversión por comprensión de lista es el enfoque “más lento”.

También he estado probando diferentes versiones de Python (3.6, 3.7, 3.8, 3.9) usando el siguiente script simple:

import argparse
import timeit

parser = argparse.ArgumentParser(
    description='Test convert iterator to list')
parser.add_argument(
    '--size', help='The number of elements from iterator')

args = parser.parse_args()

size = int(args.size)
repeat_number = 10000

# do not wait too much if the size is too big
if size > 10000:
    repeat_number = 100


def test_convert_by_type_constructor():
    list(iter(range(size)))


def test_convert_by_list_comprehension():
    [e for e in iter(range(size))]


def test_convert_by_unpacking():
    [*iter(range(size))]


def get_avg_time_in_ms(func):
    avg_time = timeit.timeit(func, number=repeat_number) * 1000 / repeat_number
    return round(avg_time, 6)


funcs = [test_convert_by_type_constructor,
         test_convert_by_unpacking, test_convert_by_list_comprehension]

print(*map(get_avg_time_in_ms, funcs))

La secuencia de comandos se ejecutará a través de un subproceso de un Jupyter Notebook (o una secuencia de comandos), el parámetro de tamaño se pasará a través de argumentos de línea de comandos y los resultados de la secuencia de comandos se tomarán de la salida estándar.

from subprocess import PIPE, run

import pandas

simple_data = {'constructor': [], 'unpacking': [], 'comprehension': [],
        'size': [], 'python version': []}


size_test = 100, 1000, 10_000, 100_000, 1_000_000
for version in ['3.6', '3.7', '3.8', '3.9']:
    print('test for python', version)
    for size in size_test:
        command = [f'python{version}', 'perf_test_convert_iterator.py', f'--size={size}']
        result = run(command, stdout=PIPE, stderr=PIPE, universal_newlines=True)
        constructor, unpacking,  comprehension = result.stdout.split()
        
        simple_data['constructor'].append(float(constructor))
        simple_data['unpacking'].append(float(unpacking))
        simple_data['comprehension'].append(float(comprehension))
        simple_data['python version'].append(version)
        simple_data['size'].append(size)

df_ = pandas.DataFrame(simple_data)
df_

Puedes obtener mi libreta completa de aquí.

En la mayoría de los casos, en mis pruebas, el desempaquetado muestra ser más rápido, pero la diferencia es tan pequeña que los resultados pueden cambiar de una ejecución a otra. Nuevamente, el enfoque de comprensión es el más lento; de hecho, los otros 2 métodos son hasta ~ 60 % más rápidos.