Pythonic way to unpack an iterator inside of a list

This might be a repeat of Fastest way to convert an iterator to a list, but your question is a bit different since you ask which is the most Pythonic. The accepted answer is list(my_iterator) over [e for e in my_iterator] because the prior runs in C under the hood. One commenter suggests [*my_iterator] is faster than list(my_iterator), so you might want to test that. My general vote is that they are all equally Pythonic, so I'd go with the faster of the two for your use case. It's also possible that the older answer is out of date.

After exploring more the subject I've come with some conclusions.

There should be one-- and preferably only one --obvious way to do it

(zen of python)

Deciding which option is the "pythonic" one should take into consideration some criteria :

• how explicit,
• simple,
• and readable it is.

And the obvious "pythonic" option winning in all criteria is option number 3):

list = list(my_iterator)

Here is why is "obvious" that no 3) is the pythonic one:

• Option 3) is close to natural language making you to 'instantly'think what is the output.
• Option 2) (using list comprehension) if you see for the first time that line of code will take you to read a little bit more and to paya bit more attention. For example, I use list comprehension when Iwant to add some extra steps(calling a function with the iteratedelements or having some checking using if statement), so when I see alist comprehension I check for any possible function call inside orfor any if statment.

• option 1) (unpacking using *) asterisk operator can be a bit confusingif you don't use it regularly, there are 4 cases for using theasterisk in Python:

  1. For multiplication and power operations.
  2. For repeatedly extending the list-type containers.
  3. For using the variadic arguments. (so-called “packing”)
  4. For unpacking the containers.

Another good argument is python docs themselves, I have done some statistics to check which options are chosen by the docs, for this I've chose 4 buil-in iterators and everything from the module itertools (that are used like: itertools.) to see how they are unpacked in a list:

• map
• range
• filter
• enumerate
• itertools.

After exploring the docs I found: 0 iterators unpacked in a list using option 1) and 2) and 35 using option 3).

Conclusion :

The pythonic way to unpack an iterator inside of a list is: my_list = list(my_iterator)

If you're interested in the least amount of typing possible, you can actually do one character better than my_list = [*my_iterator] with iterable unpacking:

*my_list, = my_iterator

or (although this only equals my_list = [*my_iterator] in the number of characters):

[*my_list] = my_iterator

(Funny how it has the same effect as my_list = [*my_iterator].)

For the most Pythonic solution, however, my_list = list(my_iterator) is clearly the clearest and the most readable of all, and should therefore be considered the most Pythonic.