Convert zip object to list Python

The zip[] function is the container that holds actual data inside. The zip[] function returns an iterator of tuples based on the iterable objects. If the given iterators have different lengths, the iterator with the least elements determines the length of the new iterator.

Python zip

The zip[] is a built-in Python function that creates an iterator that will aggregate elements from two or more iterables. It takes the iterable elements like input and returns the iterator. The zip[] method returns the zip object, the iterator of tuples where the first item in each passed iterator is paired together. Then the second item in each given iterator is paired together.

Thus, the zip[] function takes iterables [can be zero or more], makes an iterator that aggregates items based on the iterables passed and returns the iterator of tuples.

The zip[] is available in the built-in namespace.

If you use the dir[] function to inspect __builtins__, then youll see zip[] at the end of the list.

You will see the long list, but you will find the zip last.

If the zip python function gets no iterable items, it returns the empty iterator.

If you are using IPython, then type zip? And check what zip[] is about.

If you are not using IPython, install it: pip3 install ipython as I use Python 3. For Python3 users, pip install ipythonwill be just fine.

The syntax of the zip[] function in Python is the following.

The zip[] function takes:

iterables can be built-in iterables [like a list, string, dict] or user-defined iterables [an object with an __iter__ method].

The zip[] function returns the iterator of tuples based on aniterableobject.

1. If no parameters are passed on the zip function, zip[] returns the empty iterator.
2. If a single iterable is passed to the zip function, zip[] returns the iterator of 1-tuples. Meaning, the number of items in each tuple is 1.
3. If multiple iterables are passed, ithtuple contains ith Suppose, and two iterables are given, one iterable containing 3 and the other containing five elements. Then, a returned iterator has three tuples. Its because the iterator stops when the shortest iterable is exhausted.

Checking zip object in Python

If you use the zip[] with n arguments, that function will return the iterator that generates tuples of length n. We can use the Python type[] function to determine its type.

Output

Here, you use the zip[numbers, letters] to create the iterator that produces tuples of the form [x, y].

The x values are taken from the numbers, and the y values are taken from letters.

Notice how the Python zip[] function returns the iterator. Thus, to retrieve a final list object, you need to use the list[] to consume the iterator.

Passing No Arguments in Python zip[]

You call zip[] with no arguments, so your zipped variable holds an empty iterator. If you consume the iterator with a list[], then youll see an empty list as well.

See the following code.

Output

You could also force the empty iterator to yield an element directly. In this case, youll get a StopIteration exception.

Output

Python tries to retrieve the next item when you call the next[] on zipped. However, since zipped holds the empty iterator, theres nothing to pull out, so Python raises the StopIteration exception.

Passing one argument

Python zip[] function can take just one argument and returns an iterator that yields a series of 1-item tuples.

Output

You see that the length of the resulting tuples will always equal the number of iterables you pass as arguments. Lets give the three iterables.

Output

Here, you call a Python zip method with three iterables[list of strings, integers, and booleans], so the resulting tuples have three items.

Using zip[] with Python String

If youre working with sequences like the strings, your iterables are guaranteed to be evaluated from left to right. So lets define two strings, pass those in the zip[] function, and see the output.

Output

Using zip[] with Python set

The result might be weird if youre working with sequences like sets. For example, if there are three items in two sets. Now, you zip the list and convert the zipped object back to the list, but this time, the values will lose their orders.

Output

In this example, setA and setB are set objects, which dont keep their items in any particular order. Unfortunately, this means that the tuples returned by the zip[] will have items that are paired up randomly.

If youre going to use a Python zip[] function with the unordered iterables like sets, this is something to consider.

Using zip[] with Python list

The zip[] function takes the list like the following.

And zip them into one list whose entries are 3-tuples [ai, bi, ci]. Imagine drawing a zipper horizontally from left to right.

Write the following code inside theapp.pyfile.

The output is the following.

We can also convert the output to the tuple. See the following code.

The output is the following.

Python zip two lists

In python 3.0, the zip method returns the zip object.

You can get a list from it by calling list[zip[a, b]].

If you want to merge lists into a list of tuples or zip two lists, you can use the zip[] method. The pythonic approach is the following.

See the output.

You must know that a zip[] function stops at the end of the shortest list, which may not always be what you want in the output.

The itertools module defines a zip_longest[] method, which stops at the end of the longest list, filling missing values with something you provide as a parameter.

Unzipping the value using zip[]

We can also extract the data from the Python zip function. If we want to remove the zip, we must use the same zip[]function. But we have to add an asterisk[*] in front of that list you get from the zipped variable.

We can also unzip thenumList and strList.See the following example.

The output is the following.

The* operator can be used in conjunction with a zip to unzip the list.

You can use the list[] function to get the list from the zipped variable. However, this will return several tuples. The number will differ according to the number of arguments the zip function took to zip the data.

If the passed iterators have different lengths, the iterator with the least items decides the length of the new iterator. See the following example.

ThenumListhas four items, andstrListhas three elements. So the lengths are not matched. Lets see the output.

Zip three iterators

Lets take an example in which we can use three iterators and then use the zip function on it.

The output is the following.

We took three different variables and then used the zip[] function and converted it into the iterable.

Comparing Python 2 zip[] with Python 3 zip[]

The zip[] function works differently in both versions of the Python.

In Python 2, the zip[] method returns a list of tuples. The output list is truncated to the length of the shortest input iterable. If you call the zip[] with no arguments, you get an empty list in return.

See the following code in Python2.

Output

In this case, your call to the Python zip[] method returns a list of tuples truncated at the value Z.

Now, lets call a zip[] with no arguments.

Output

You get an empty list when you call the zip[] method with no arguments.

If you supply no arguments to zip[], the function returns an empty iterator.

Output

When we give no argument to the zip[] function in Python 3, you will get an empty iterator.

If you frequently use Python 2, then note that using the zip[] method with long input iterables can inadvertently consume a lot of memory. In these cases, consider using the itertools.izip[*iterables] instead. This function creates the iterator that aggregates items from each of the iterables. It produces the same effect as the zip[] function in Python 3. But I recommend updating the Python from 2 to 3 and using the Python 3 zip[] function.

Looping Over Multiple Iterables

Python zip[] functions most use case is Looping over multiple iterables. If you need to iterate over multiple lists, tuples, or any other sequence, then its likely that youll recede on the zip[].

Traversing Lists in Parallel

The zip[] function allows us to iterate in parallel over two or more iterables. Since the zip[] function generates tuples, you can unpack these in a for loop header.

Output

To print the value in the console, we have formatted the string.

Here, you iterate over the series of tuples returned by the zip[] and unpack the elements into a and b. When you combine the zip[], for loops, and tuple unpacking, you can get a convenient and Pythonic jargon for traversing two or more iterables at once.

You can also iterate over two iterables in a single for loop. Consider the below example, which has three input iterables.

Output

In this example, you have used the zip[] with three iterables to create and return the iterator that generates 3-item tuples. This grants us to iterate over all three iterables in one go. There are no limitations on the number of iterables you can use with Pythons zip[] function.

Traversing Dictionaries in Parallel using zip[]

From Python 3.6 and beyond, dictionaries are ordered collections, meaning they keep their items in the same order they were lead first. If you leverage this aspect, you can use the Python zip[] function to iterate over multiple dictionaries safely and coherently.

Output

Here, you iterate through dictA and dictB in parallel. In this case, zip[] creates tuples with the elements from both dictionaries. Then, you can unbox each tuple and gain access to the items of both dictionaries at the same timekids stuff.

You can also use the zip[] function to iterate over sets in parallel. However, youll have to consider that, unlike dictionaries in Python 3.6, sets dont keep their items in the order. If you forget this detail, the final output of your program may not be quite what you want or expect.

Sorting in Parallel

Lets say you have to combine two lists[one is a list of ints and one is a list of strings] and sort them simultaneously. To do this, we can use zip[] and the sorted[] method as follows.

Output

In this case, sorted[] runs over the iterator generated by the zip[] and sorts the items by integers, all in one go. This way can be a little faster since youll need only two function calls: zip[] and sorted[].

With sorted[], youre also writing the more general piece of code that makes sense to other programmers. For example, this will enable you to sort any sequence, not just lists.

Conclusion

In this in-depth tutorial, youve learned how to use Pythons zip[] function. The zip[] can receive multiple iterables as input and returns an iterator to create tuples with paired items from each argument. The final iterator can be helpful when you need to process the multiple iterables in the single for loop and perform some actions on their items simultaneously. That is it for this tutorial.

Recommended Posts

Python ascii[]

Python bin[]

Python bool[]

Python any[]

Python all[]

Video liên quan