What Is an Iterator in Python?

In Python, an iterator is an object that allows you to iterate over collections of data, such aslists, tuples,dictionaries, andsets.

Python iterators implement theiterator design pattern, which allows you to traverse a container and access its elements. The iterator pattern decouples the iterationalgorithms from containerdata structures.

Iterators take responsibility for two main actions:

1. Returning the data from a stream or containerone item at a time
2. Keeping track of thecurrent andvisited items

In summary, an iterator will yield each item or value from a collection or a stream of data while doing all the internal bookkeeping required to maintain the state of the iteration process.

Python iterators must implement a well-established internal structure known as theiterator protocol. In the following section, you’ll learn the basics of this protocol.

What Is the Python Iterator Protocol?

A Python object is considered an iterator when it implements twospecial methods collectively known as theiterator protocol. These two methods make Python iterators work. So, if you want to create custom iterator classes, then you must implement the following methods:

The.__iter__() method of an iterator typicallyreturnsself, which holds a reference to the current object: the iterator itself. This method is straightforward to write and, most of the time, looks something like this:

def__iter__(self):returnself

The only responsibility of.__iter__() is to return an iterator object. So, this method will typically just returnself, which holds the current instance. Don’t forget that this instancemust define a.__next__() method.

The.__next__() method will be a bit more complex depending on what you’re trying to do with your iterator. This method must return the next item from the data stream. It should also raise aStopIteration exception when no more items are available in the data stream. This exception will make the iteration finish. That’s right. Iterators useexceptions forcontrol flow.

When to Use an Iterator in Python?

The most generic use case of a Python iterator is to allow iteration over a stream of data or a container data structure. Python uses iterators under the hood to support every operation that requires iteration, includingfor loops,comprehensions,iterable unpacking, and more. So, you’re constantly using iterators without being conscious of them.

In your day-to-day programming, iterators come in handy when you need to iterate over a dataset or data stream with an unknown or a huge number of items. This data can come from different sources, such as your local disk, a database, and a network.

In these situations, iterators allow you to process the datasets one item at a time without exhausting the memory resources of your system, which is one of the most attractive features of iterators.

Yielding the Original Data

Okay, now it’s time to learn how to write your own iterators in Python. As a first example, you’ll write a classic iterator calledSequenceIterator. It’ll take asequence data type as an argument and yield its items on demand.

Fire up your favoritecode editor or IDE and create the following file:

classSequenceIterator:def__init__(self,sequence):self._sequence=sequenceself._index=0def__iter__(self):returnselfdef__next__(self):ifself._index<len(self._sequence):item=self._sequence[self._index]self._index+=1returnitemelse:raiseStopIteration

YourSequenceIterator will take a sequence of values atinstantiation time. The classinitializer,.__init__(), takes care of creating the appropriateinstance attributes, including the input sequence and an._index attribute. You’ll use this latter attribute as a convenient way to walk through the sequence using indices.

The.__iter__() method does only one thing: returns the current object,self. In this case,self is the iterator itself, which implies it has a.__next__() method.

Finally, you have the.__next__() method. Inside it, you define aconditional statement to check if the current index is less than the number of items in the input sequences. This check allows you to stop the iteration when the data is over, in which case theelse clause will raise aStopIteration exception.

In theif clause, you grab the current item from the original input sequence using its index. Then you increment the._index attribute using anaugmented assignment. This action allows you to move forward in the iteration while you keep track of the visited items. The final step is to return the current item.

Here’s how your iterator works when you use it in afor loop:

>>>fromsequence_iterimportSequenceIterator>>>foriteminSequenceIterator([1,2,3,4]):...print(item)...1234

Great! Your custom iterator works as expected. It takes a sequence as an argument and allows you to iterate over the original input data.

Before diving into another example, you’ll learn how Python’sfor loops work internally. The following code simulates the complete process:

>>>sequence=SequenceIterator([1,2,3,4])>>># Get an iterator over the data>>>iterator=sequence.__iter__()>>>whileTrue:...try:...# Retrieve the next item...item=iterator.__next__()...exceptStopIteration:...break...else:...# The loop's code block goes here......print(item)...1234

After instantiatingSequenceIterator, the code prepares thesequence object for iteration by calling its.__iter__() method. This method returns the actual iterator object. Then, the loop repeatedly calls.__next__() on the iterator to retrieve values from it.

When a call to.__next__() raises theStopIteration exception, you break out of the loop. In this example, the call toprint() under theelse clause of thetry block represents the code block in a normalfor loop. As you can see, thefor loop construct is a kind ofsyntactic sugar for a piece of code like the one above.

Transforming the Input Data

Say that you want to write an iterator that takes a sequence of numbers, computes the square value of each number, and yields those values on demand. In this case, you can write the following class:

classSquareIterator:def__init__(self,sequence):self._sequence=sequenceself._index=0def__iter__(self):returnselfdef__next__(self):ifself._index<len(self._sequence):square=self._sequence[self._index]**2self._index+=1returnsquareelse:raiseStopIteration

The first part of thisSquareIterator class is the same as yourSequenceIterator class. The.__next__() method is also pretty similar. The only difference is that before returning the current item, the method computes its square value. This computation performs a transformation on each data point.

Here’s how the class will work in practice:

>>>fromsquare_iterimportSquareIterator>>>forsquareinSquareIterator([1,2,3,4,5]):...print(square)...1491625

Using an instance ofSquareIterator in afor loop allows you to iterate over the square values of your original input values.

The option of performing data transformation on a Python iterator is a great feature. It can make your code quite efficient in terms of memory consumption. Why? Well, imagine for a moment that iterators didn’t exist. In that case, if you wanted to iterate over the square values of your original data, then you’d need to create a new list to store the computed squares.

This new list would consume memory because it would have to store all the data simultaneously. Only then would you be able to iterate over the square values.

However, if you use an iterator, then your code will only require memory for a single item at a time. The iterator will compute the following items on demand without storing them in memory. In this regard, iterators arelazy objects.

Generating New Data

You can also create custom iterators that generate a stream of new data from a given computation without taking a data stream as input. Consider the following iterator, which producesFibonacci numbers:

classFibonacciIterator:def__init__(self,stop=10):self._stop=stopself._index=0self._current=0self._next=1def__iter__(self):returnselfdef__next__(self):ifself._index<self._stop:self._index+=1fib_number=self._currentself._current,self._next=(self._next,self._current+self._next,)returnfib_numberelse:raiseStopIteration

This iterator doesn’t take a data stream as input. Instead, it generates each item by performing a computation that yields values from the Fibonacci sequence. You do this computation inside the.__next__() method.

You start this method with a conditional that checks if the current sequence index hasn’t reached the._stop value, in which case you increment the current index to control the iteration process. Then you compute the Fibonacci number that corresponds to the current index, returning the result to the caller of.__next__().

When._index grows to the value of._stop, you raise aStopIteration, which terminates the iteration process. Note that you should provide a stop value when you call theclass constructor to create a new instance. Thestop argumentdefaults to10, meaning the class will generate ten Fibonacci numbers if you create an instance without arguments.

Here’s how you can use thisFibonacciIterator class in your code:

>>>fromfib_iterimportFibonacciIterator>>>forfib_numberinFibonacciIterator():...print(fib_number)...0112358132134

Instead of yielding items from an existing data stream, yourFibonacciIterator class computes every new value in real time, yielding values on demand. Note that in this example, you relied on the default number of Fibonacci numbers, which is10.

Coding Potentially Infinite Iterators

An interesting feature of Python iterators is that they can handle potentially infinite data streams. Yes, you can create iterators that yield values without ever reaching an end! To do this, you just have to skip theStopIteration part.

For example, say that you want to create a new version of yourFibonacciIterator class that can produce potentially infinite Fibonacci numbers. To do that, you just need to remove theStopIteraton and the condition that raises it:

classFibonacciInfIterator:def__init__(self):self._index=0self._current=0self._next=1def__iter__(self):returnselfdef__next__(self):self._index+=1self._current,self._next=(self._next,self._current+self._next)returnself._current

The most relevant detail in this example is that.__next__() never raises aStopIteration exception. This fact turns the instances of this class into potentiallyinfinite iterators that would produce values forever if you used the class in afor loop.

To check if yourFibonacciInfIterator works as expected, go ahead and run the following loop. But remember, it’ll be an infinite loop:

>>>frominf_fibimportFibonacciInfIterator>>>forfib_numberinFibonacciInfIterator():...print(fib_number)...0112358132134Traceback (most recent call last):...KeyboardInterrupt

When you run this loop in your Pythoninteractive session, you’ll notice that the loop prints numbers from the Fibonacci sequence without stopping. To stop the loops, go ahead and pressCtrl+C.

As you’ve confirmed in this example, infinite iterators likeFibonacciInfIterator will makefor loops run endlessly. They’ll also cause functions that accept iterators—such assum(),max(), andmin()—to never return. So, be careful when using infinite iterators in your code, as you can make your code hang.

Inheriting Fromcollections.abc.Iterator

Thecollections.abc module includes anabstract base class (ABC) calledIterator. You can use this ABC to create your custom iterators quickly. This class provides basic implementations for the.__iter__() method.

It also provides a.__subclasshook__() class method that ensures only classes implementing the iterator protocol will be considered subclasses ofIterator.

Check out the following example, in which you change yourSequenceIterator class to use theIterator ABC:

fromcollections.abcimportIteratorclassSequenceIterator(Iterator):def__init__(self,sequence):self._sequence=sequenceself._index=0def__next__(self):ifself._index<len(self._sequence):item=self._sequence[self._index]self._index+=1returnitemelse:raiseStopIteration

If you inherit fromIterator, then you don’t have to write an.__iter__() method because the superclass already provides one with the standard implementation. However, you do have to write your own.__next__() method because the parent class doesn’t provide a working implementation.

Here’s how this class works:

>>>fromsequence_iterimportSequenceIterator>>>fornumberinSequenceIterator([1,2,3,4]):...print(number)...1234

As you can see, this new version ofSequenceIterator works the same as your original version. However, this time you didn’t have to code the.__iter__() method. Your class inherited this method fromIterator.

The features inherited from theIterator ABC are useful when you’re working with class hierarchies. They’ll take work off your plate and save you headaches.

Creating Generator Functions

To create a generator function, you must use theyield keyword to yield the values one by one. Here’s how you can write a generator function that returns an iterator that’s equivalent to yourSequenceIterator class:

>>>defsequence_generator(sequence):...foriteminsequence:...yielditem...>>>sequence_generator([1,2,3,4])<generator object sequence_generator at 0x108cb6260>>>>fornumberinsequence_generator([1,2,3,4]):...print(number)...1234

Insequence_generator(), you accept a sequence of values as an argument. Then you iterate over that sequence using afor loop. In each iteration, the loop yields the current item using theyield keyword. This logic is then packed into a generator iterator object, which automatically supports the iterator protocol.

You can use this iterator in afor loop as you would use aclass-based iterator. Internally, the iterator will run the original loop, yielding items on demand until the loop consumes the input sequence, in which case the iterator will automatically raise aStopIteration exception.

Generator functions are a great tool for creatingfunction-based iterators that save you a lot of work. You just have to write a function, which will often be less complex than a class-based iterator. If you comparesequence_generator() with its equivalent class-based iterator,SequenceIterator, then you’ll note a big difference between them. The function-based iterator is way simpler and more straightforward to write and understand.

Using Generator Expressions to Create Iterators

If you like generator functions, then you’ll lovegenerator expressions. These are particular types of expressions that return generator iterators. The syntax of a generator expression is almost the same as that of a list comprehension. You only need to turn the square brackets ([]) into parentheses:

>>>[itemforitemin[1,2,3,4]]# List comprehension[1, 2, 3, 4]>>>(itemforitemin[1,2,3,4])# Generator expression<generator object <genexpr> at 0x7f55962bef60>>>>generator_expression=(itemforitemin[1,2,3,4])>>>foritemingenerator_expression:...print(item)...1234

Wow! That was really neat! Your generator expression does the same as its equivalent generator function. The expression returns a generator iterator that yields values on demand. Generator expressions are an amazing tool that you’ll probably use a lot in your code.

Exploring Different Types of Generator Iterators

As you’ve already learned, classic iterators typically yield data from an existing iterable, such as a sequence or collection data structure. The examples in the above section show that generators can do just the same.

However, as their name suggests, generators cangenerate streams of data. To do this, generators may or may not take input data. Like class-based iterators, generators allow you to:

• Yield theinput data as is
• Transform the input and yield a stream oftransformed data
• Generate anew stream of data out of a known computation

To illustrate the second use case, check out how you can write an iterator of square values using a generator function:

>>>defsquare_generator(sequence):...foriteminsequence:...yielditem**2...>>>forsquareinsquare_generator([1,2,3,4,5]):...print(square)...1491625

Thissquare_generator() function takes a sequence and computes the square value of each of its items. Theyield statement yields square items on demand. When you call the function, you get a generator iterator that generates square values from the original input data.

Alternatively, generators can just generate the data by performing some computation without the need for input data. That was the case with yourFibonacciIterator iterator, which you can write as a generator function like the following:

>>>deffibonacci_generator(stop=10):...current_fib,next_fib=0,1...for_inrange(0,stop):...fib_number=current_fib...current_fib,next_fib=(...next_fib,current_fib+next_fib...)...yieldfib_number...>>>list(fibonacci_generator())[0, 1, 1, 2, 3, 5, 8, 13, 21, 34]>>>list(fibonacci_generator(15))[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377]

This functional version of yourFibonacciIterator class works as expected, producing Fibonacci numbers on demand. Note how you’ve simplified the code by turning your iterator class into a generator function. Finally, to display the actual data, you’ve calledlist() with the iterator as an argument. These calls implicitly consume the iterators, returning lists of numbers.

In this example, when the loop finishes, the generator iterator automatically raises aStopIteration exception. If you want total control over this process, then you can terminate the iteration yourself by using anexplicitreturn statement:

deffibonacci_generator(stop=10):current_fib,next_fib=0,1index=0whileTrue:ifindex==stop:returnindex+=1fib_number=current_fibcurrent_fib,next_fib=next_fib,current_fib+next_fibyieldfib_number

In this version offibonacci_generator(), you use awhile loop to perform the iteration. The loop checks the index in every iteration and returns when the index has reached thestop value.

You’ll use areturn statement inside a generator function to explicitly indicate that the generator is done. Thereturn statement will make the generator raise aStopIteration.

Just like class-based iterators, generators are useful when you need to process a large amount of data, including infinite data streams. You can pause and resume generators, and you can iterate over them. They generate items on demand, so they’re also lazy. Both iterators and generators are pretty efficient in terms of memory usage. You’ll learn more about this feature in the following section.

Returning Iterators Instead of Container Types

Regular functions and comprehensions typically create a container type like a list or a dictionary to store the data that results from the function’s intended computation. All this data is stored in memory at the same time.

In contrast, iterators keep only one data item in memory at a time, generating the next items on demand or lazily. For example, get back to the square values generator. Instead of using a generator function that yields values on demand, you could’ve used a regular function like the following:

>>>defsquare_list(sequence):...squares=[]...foriteminsequence:...squares.append(item**2)...returnsquares...>>>numbers=[1,2,3,4,5]>>>square_list(numbers)[1, 4, 9, 16, 25]

In this example, you have two list objects: the original sequence ofnumbers and the list of square values that results from callingsquare_list(). In this case, the input data is fairly small. However, if you start with a huge list of values as input, then you’ll be using a large amount of memory to store the original and resulting lists.

In contrast, if you use a generator, then you’ll only need memory for the input list and for a single square value at a time.

Similarly, generator expressions are more memory-efficient than comprehensions. Comprehensions create container objects, while generator expressions return iterators that produce items when needed.

Another important memory-related difference between iterators, functions, data structures, and comprehensions is that iterators are the only way to process infinite data streams. In this situation, you can’t use a function that creates a new container directly, because your input data is infinite, which will hang your execution.

Creating a Data Processing Pipeline With Generator Iterators

As mentioned before, you can use iterators and generators to build memory-efficient data processing pipelines. Your pipeline can consist of multiple separate generator functions performing a single transformation each.

For example, say you need to perform a bunch of mathematical tranformations on a sample of integer numbers. You may need to raise the values to the power of two or three, filter even and odd numbers, and finally convert the data into string objects. You also need your code to be flexible enough that you can decide which specific set of transformations you need to run.

Here’s your set of individual generator functions:

defto_square(numbers):return(number**2fornumberinnumbers)defto_cube(numbers):return(number**3fornumberinnumbers)defto_even(numbers):return(numberfornumberinnumbersifnumber%2==0)defto_odd(numbers):return(numberfornumberinnumbersifnumber%2!=0)defto_string(numbers):return(str(number)fornumberinnumbers)

All these functions take some sample data as theirnumbers argument. Each function performs a specific mathematical transformation on the input data and returns an iterator that produces transformed values on demand.

Here’s how you can combine some of these generator functions to create different data processing pipelines:

>>>importmath_pipelineasmpl>>>list(mpl.to_string(mpl.to_square(mpl.to_even(range(20)))))['0', '4', '16', '36', '64', '100', '144', '196', '256', '324']>>>list(mpl.to_string(mpl.to_cube(mpl.to_odd(range(20)))))['1', '27', '125', '343', '729', '1331', '2197', '3375', '4913', '6859']

Your first pipeline takes some numbers, extracts the even ones, finds the square value of those even numbers, and finally converts each resulting value into a string object. Note how each function provides the required argument for the next function on the pipeline. The second pipeline works similarly.

The Iterable Protocol

The iterable protocol consists of a single special method that you already know from the section on the iterator protocol. The.__iter__() method fulfills the iterable protocol. This method must return an iterator object, which usually doesn’t coincide withself unless your iterable is also an iterator.

To quickly jump into an example of how the iterable protocol works, you’ll reuse theSequenceIterator class from previous sections. Here’s the implementation:

fromsequence_iterimportSequenceIteratorclassIterable:def__init__(self,sequence):self.sequence=sequencedef__iter__(self):returnSequenceIterator(self.sequence)

In this example, yourIterable class takes a sequence of values as an argument. Then, you implement an.__iter__() method that returns an instance ofSequenceIterator built with the input sequence. This class is ready for iteration:

>>>fromsequence_iterableimportIterable>>>forvalueinIterable([1,2,3,4]):...print(value)...1234

The.__iter__() method is what makes an object iterable. Behind the scenes, the loop calls this method on the iterable to get an iterator object that guides the iteration process through its.__next__() method.

Note that iterables aren’t iterators on their own. So, you can’t use them as direct arguments to thenext() function:

>>>numbers=Iterable([1,2,3,4])>>>next(numbers)Traceback (most recent call last):...TypeError:'Iterable' object is not an iterator>>>letters="ABCD">>>next(letters)Traceback (most recent call last):...TypeError:'str' object is not an iterator>>>fruits=[..."apple",..."banana",..."orange",..."grape",..."lemon",...]>>>next(fruits)Traceback (most recent call last):...TypeError:'list' object is not an iterator

You can’t pass an iterable directly to thenext() function because, in most cases, iterables don’t implement the.__next__() method from the iterator protocol. This is intentional. Remember that the iterator pattern intends to decouple the iteration algorithm from data structures.

Note how both custom iterables and built-in iterables, such as strings and lists, fail to supportnext(). In all cases, you get aTypeError telling you that the object at hand isn’t an iterator.

Ifnext() doesn’t work, then how can iterables work infor loops? Well,for loops always call the built-initer() function to get an iterator out of the target stream of data. You’ll learn more about this function in the next section.

The Built-initer() Function

From Python’s perspective, an iterable is an object that can be passed to the built-initer() function to get an iterator from it. Internally,iter() falls back to calling.__iter__() on the target objects. So, if you want a quick way to determine whether an object is iterable, then use it as an argument toiter(). If you get an iterator back, then your object is iterable. If you get an error, then the object isn’t iterable:

>>>fruits=[..."apple",..."banana",..."orange",..."grape",..."lemon",...]>>>iter(fruits)<list_iterator object at 0x105858760>>>>iter(42)Traceback (most recent call last):...TypeError:'int' object is not iterable

When you pass an iterable object, like a list, as an argument to the built-initer() function, you get an iterator for the object. In contrast, if you calliter() with an object that’s not iterable, like an integer number, then you get aTypeError exception.

The Built-inreversed() Function

Python’s built-inreversed() function allows you to create an iterator that yields the values of an input iterable in reverse order. Аsiter() falls back to calling.__iter__() on the underlying iterable,reversed() delegates on a special method called.__reverse__() that’s present in ordered built-in types, such as lists, tuples, and dictionaries.

Other ordered types, such as strings, also supportreversed() even though they don’t implement a.__reverse__() method.

Here’s an example of howreversed() works:

>>>digits=[0,1,2,3,4,5,6,7,8,9]>>>reversed(digits)<list_reverseiterator object at 0x1053ff490>>>>list(reversed(digits))[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]

In this example, you usereversed() to create an iterator object that yields values from thedigits list in reverse order.

To do its job,reversed() falls back to calling.__reverse__() on the input iterable. If that iterable doesn’t implement.__reverse__(), thenreversed() checks the existence of.__len__() and.__getitem___(index). If these methods are present, thenreversed() uses them to iterate over the data sequentially. If none of these methods are present, then callingreversed() on such an object will fail.

The Sequence Protocol

Sequences are container data types that store items in consecutive order. Each item is quickly accessible through a zero-based index that reflects the item’s relative position in the sequence. You can use this index and the indexing operator ([]) to access individual items in the sequence:

>>>numbers=[1,2,3,4]>>>numbers[0]1>>>numbers[2]3

Integer indices give you access to individual values in the underlying list of numbers. Note that the indices start from zero.

All built-in sequence data types—like lists, tuples, and strings—implement the sequence protocol, which consists of the following methods:

• .__getitem__(index) takes an integer index starting from zero and returns the items at that index in the underlying sequence. It raises anIndexError exception when the index is out of range.
• .__len__() returns the length of the sequence.

When you use an object that supports these two methods, Python internally calls.__getitem__() to retrieve each item sequentially and.__len__() to determine the end of the data. This means that you can use the object in a loop directly.

To check this internal behavior of Python, consider the following class, which implements a minimalstack data structure using a list to store the actual data:

classStack:def__init__(self):self._items=[]defpush(self,item):self._items.append(item)defpop(self):try:returnself._items.pop()exceptIndexError:raiseIndexError("pop from an empty stack")fromNonedef__getitem__(self,index):returnself._items[index]def__len__(self):returnlen(self._items)

ThisStack class provides the two core methods that you’ll typically find in a stack data structure. Thepush() method allows you to add items to the top of the stack, while thepop() method removes and returns items from the top of the stack. This way, you guarantee that your stack works according to the LIFO (last in, first out) principle.

The class also implements the Python sequence protocol. The.__getitem__() method returns the item atindex from the underlying list object,._items. Meanwhile, the.__len__() method returns the number of items in the stack using the built-inlen() function.

These two methods make yourStack class iterable:

>>>fromstackimportStack>>>stack=Stack()>>>stack.push(1)>>>stack.push(2)>>>stack.push(3)>>>stack.push(4)>>>iter(stack)<iterator object at 0x104e9b460>>>>forvalueinstack:...print(value)...1234

YouStack class doesn’t have an.__iter__() method. However, Python is smart enough to build an iterator using.__getitem__() and.__len__(). So, your class supportsiter() and iteration. You’ve created an iterable without formally implementing the iterable protocol.

Iterating Through Iterables Withfor Loops

Iterables shine in the context of iteration. They’re especially useful indefinite iteration, which usesfor loops to access the items in iterable objects. Python’sfor loops are specially designed to traverse iterables. That’s why you can use iterables directly in this type of loop:

>>>fornumberin[1,2,3,4]:...print(number)...1234

Internally, the loop creates the required iterator object to control the iteration. This iterator keeps track of the item currently going through the loop. It also takes care of retrieving consecutive items from the iterable and finishing the iteration when the data is over.

Iterating Through Comprehensions

Python also allows you to use iterables in another kind of iteration known as comprehensions. Comprehensions work similarly tofor loops but have a more compact syntax.

You can use comprehensions to create new lists, dictionaries, and sets from existing iterables of data. In all cases, the comprehension construct will iterate over the input data, transform it, and generate a new container data type.

For example, say that you want to process a list of numeric values and create a new list with cube values. In this case, you can use the following list comprehension to perform the data transformation:

>>>numbers=[1,2,3,4]>>>[number**3fornumberinnumbers][1, 8, 27, 64]

This list comprehension builds a new list of cube values from the original data innumbers. Note how the syntax of a comprehension resembles afor loop with the code block at the beginning of the construct.

You can also use comprehensions to process iterables conditionally. To do this, you can add one or more conditions at the end of the comprehension construct:

>>>numbers=[1,2,3,4,5,6]>>>[numberfornumberinnumbersifnumber%2==0][2, 4, 6]

The condition at the end of this comprehension filters the input data, creating a new list with even numbers only.

Comprehensions are popular tools in Python. They provide a great way to process iterables of data quickly and concisely. To dive deeper into list comprehensions, check outWhen to Use a List Comprehension in Python.

Unpacking Iterables

In Python, you can use iterables in a type of operation known asiterable unpacking. Unpacking an iterable means assigning its values to a series of variables one by one. The variables must come as a tuple or list, and the number of variables must match the number of values in the iterable.

Iterable unpacking can help you write more concise, readable code. For example, you may find yourself doing something like this:

>>>numbers=[1,2,3,4]>>>one=numbers[0]>>>two=numbers[1]>>>three=numbers[2]>>>four=numbers[3]>>>one1>>>two2>>>three3>>>four4

If this is your case, then go ahead and replace the series of individualassignments with a more readable iterable unpacking operation using a single, elegant assignment like the following:

>>>numbers=[1,2,3,4]>>>one,two,three,four=numbers>>>one1>>>two2>>>three3>>>four4

In this example,numbers is an iterable containing numeric data. The assignment unpacks the values innumbers into the four target variables. To do this, Python internally runs a quick loop over the iterable on the right-hand side to unpack its values into the target variables.

The above example shows the most common form of iterable unpacking in Python. The main condition for the example to work is that the number of variables must match the number of values in the iterable.