Zip Variable Empty After First Use

zip variable empty after first use

That's how it works in python 3.x. In python2.x, zip returned a list of tuples, but for python3.x, zip behaves like itertools.izip behaved in python2.x. To regain the python2.x behavior, just construct a list from zip's output:

z = list(zip(t,t2))

Note that in python3.x, a lot of the builtin functions now return iterators rather than lists (map, zip, filter)

python list(zipobject) returns empty (list) container

This problem will not be created by list(aabb) but with list(ab) in your code right now:

a = [1, 2, 3, 4]
b = [5, 6, 7, 8]

ab = zip(a, b)
aabb = list(ab)

print(list(ab))  # -> []

The problem is that zip is an iterator which stores values once and are then disposed like so:

ab = zip(a, b)  # iterator created
aabb = list(ab)  # elements read from ab, disposed, placed in a list

print(list(ab))  # now ab has nothing because it was exhausted

This on the other hand should work because aabb is just a list, not the exhausted iterator ab:

ab = zip(a, b)
aabb = list(ab)

print(list(aabb))  # -> [(1, 5), (2, 6), (3, 7), (4, 8)]

Zip variable becomes empty after running subsequent code

In short, the problem is your title concept: "zip variable". This is not a static list; it's a generator object.

buckets = zip(starts, ends)

buckets is a callable interface, a function with a yield. Once you've iterated through the underlying structure, the generator is exhausted; any further references will yield None.

If you want to iterate multiple times, either re-create the zip expression on each use, or store it as a list:

buckets = list(zip(starts, ends))

Why I'm getting empty list after using zip in python?

zip returns an iterator object. The first time you convert it to a list, the iterator is consumed, and after that point it's empty. You'll get the behavior you expect if you convert it to a list immediately and then copy it:

result = list(zip(number_list, str_list))

# Converting list to more lists
result_list = result.copy()
result_list2 = result.copy()

In general, a zip object is meant to be used immediately (e.g. within a for loop or passed directly to a function that takes an iterable). Assigning the result of calling zip to a variable is not going to be useful in very many cases.

why return empty list when calling list on zip twice

Because zip is an Iterator object. When you call list(ll) for the first time, the values in the zip objects, get consumed. That is why when you call list again, there is nothing else to show.

zip is a function, that when applied on iterables, returns an iterator. Meaning, unless it is being iterated on, it does not calculate any value.

For example:

>>> z = zip([1, 2, 3], [3, 4, 5])
>>> z
<zip at 0x1e46824bec0>

>>> next(z)    # One value is computed, thus consumed, now if you call list:
(1, 3)

>>> list(z)    # There were only two left, and now even those two are consumed
[(2, 4), (3, 5)]

>>> list(z)    # Returns empty list because there is nothing to consume
[]

Printing an unzipped list object returns empty list

zip returns an iterator. In Python, iterators can be consumed, meaning once you iterate over them, you cannot do it again. When you executed list(z), you consumed iterator z so unpacking it in zip(*z) gave you an empty iterator.

The idea behind consuming iterators is that they use very little space (complexity is O(1)), so you cannot iterate over them multiple times because that would mean you have to store all the values, leading to O(n) complexity. When you iterate over a collection multiple times, you are actually generating a new iterator every time.

list in python is empty

Zip returns an iterator. Once you consume the iterator then it will continue to return empty.

If you consume the iterator with list(), then you’ll see an empty list as well.

https://realpython.com/python-zip-function/

Python zip behavour - Can someone explain this

Edit: the answer previously stated 'generator' instead of 'iterator', but @juanpa.arrivillaga correctly pointed out that the zip object is in fact an iterator (which works essentially the same from a user perspective, but does not have the same overhead)

z is an iterator and your first use of it in print(list(z)) exhausts it. You should repeat z=zip(x,y) before the 4th print statement. Note that you still see it as a <zip object> in the 3rd print statement because it is, it's just an exhausted zip object. And the first use doesn't exhaust it.

x = [1]
y = [2]
z = zip(x,y)    # zip object created, ready to yield values

print(z)        # print z, the object
print(list(z))  # exhaust z into a list, print the list
print(z)        # print z, the object (now exhausted)
print(list(z))  # try to exhaust z into a list again, nothing there, print []

Try this:

x=[1]
y=[2]
z=zip(x,y)

print(z)
print(list(z))
print(z)
z=zip(x,y)
print(list(z))
print(list(zip(x,y)))

Python zip object can be used only once. Why is that?

zip produces an iterator (<zip object at 0x03DB18F0>) which can only be iterated once. Once you have iterated it, it's exhausted. If you want to produce a list which can be iterated as often as you like:

zipped = list(zip(names, ages))

Printing a zip from dictionary return Empty list

you can use zip one time because it iter object

you can convert it to list object

import copy
l1= {'a':6, 'b':5, 'c':3, 'd':2, 'e':1, 'f':7, 'g':4, 'h':9}
l2={'a':7, 'b':5, 'c':2, 'd':3, 'e':8}

z=list(zip(l1.values(),l2.values()))
print(list(z)) #This gives me correct output.
print(list(z)) #This gives me EMPTY list. WHY?

output

[(6, 7), (5, 5), (3, 2), (2, 3), (1, 8)]
[(6, 7), (5, 5), (3, 2), (2, 3), (1, 8)]

---

Related Topics