Jinja List: filter function to convert iterable into a list

n

What is the Jinja list Filter?

nThe Jinja list filter is a simple but essential tool used to convert an iterable into a list. This filter is useful when you have a value that might not be a list—like an iterator, a string, or a dictionary—and you need to perform list-specific operations on it, such as accessing elements by their index, slicing, or reversing. The list filter essentially materializes the entire sequence into a list in memory, making it a reliable way to get a complete, manipulable sequence of items.nn

---

nn

How the list Filter Works

nThe list filter takes any iterable as its input and returns a Python list containing all the items from that iterable. The filter is straightforward and doesn’t have any optional parameters.nnThe basic syntax looks like this:n

{{ my_iterable | list }}

nIt’s important to understand what the filter does with different types of input:n

n
• On an iterable (e.g., a generator or a set): The filter will iterate through all the elements and build a standard list. This is useful for capturing the results of another filter (like map or select) that returns an iterator.

n

• On a string: The filter will convert the string into a list of its characters. For example, the string "Hello" becomes ['H', 'e', 'l', 'l', 'o'].

n

• On a dictionary: The filter will convert the dictionary into a list of its keys. For example, {'a': 1, 'b': 2} becomes ['a', 'b']. If you want the values, you’d first need to use the dict.values() method.

n

nKeep in mind that since the list filter creates a new list in memory; it can be resource-intensive if you’re working with a very large dataset. For such cases, using iterators directly (e.g., in a for loop) is generally more memory-efficient.nn

---

nn

Practical Examples

nLet’s see some practical examples of the list filter in action.n

Example 1: Converting a String into a List of Characters

nThis is a common use case for when you need to iterate over the individual characters of a string.nnJinja Template:n

{% set my_string = "Jinja" %}n<p>The original string is: {{ my_string }}</p>nn{% set characters = my_string | list %}n<p>The list of characters is: {{ characters }}</p>n<p>The second character is: {{ characters[1] }}</p>

nRendered HTML:n

<p>The original string is: Jinja</p>n<p>The list of characters is: ['J', 'i', 'n', 'j', 'a']</p>n<p>The second character is: i</p>

nThe filter successfully converts the string into a list of characters, allowing you to access a specific character by its index.n

Example 2: Materializing the Result of Another Filter

nMany Jinja filters, like map, return an iterator. To use the result differently—for example, to get a specific item by index—you need to convert the iterator to a list first.nnJinja Template:n

{% set users = [n    {'name': 'Alice'},n    {'name': 'Bob'},n    {'name': 'Charlie'}n] %}nn{% set names = users | map(attribute='name') %}n<p>All names: {{ names | list }}</p>n<p>The second name is: {{ (users | map(attribute='name') | list)[1] }}</p>

nRendered HTML:n

<p>All names: ['Alice', 'Bob', 'Charlie']</p>n<p>The second name is: Bob</p>

nThe map filter produces an iterator of the names, and the list filter converts it into a tangible list that can be indexed.n

Example 3: Reversing a String with list and reverse

nA good example of list being used with another filter is reversing a string. The reverse filter on its own works on strings but returns an iterator of characters. To get a new reversed string, you’d use list and join.nnJinja Template:n

{% set my_string = "Jinja" %}n{% set reversed_string = my_string | list | reverse | join('') %}n<p>Original string: {{ my_string }}</p>n<p>Reversed string: {{ reversed_string }}</p>

nRendered HTML:n

<p>Original string: Jinja</p>n<p>Reversed string: ajniJ</p>

nHere, list converts the string to a list of characters, reverse reverses the order of that list, and join combines the characters back into a string.nn

---

nn

Conclusion

nThe Jinja list filter is a simple but powerful conversion tool. It is particularly useful for transforming iterables and strings into a full list, enabling you to use all the list-specific features of Python within your templates. By understanding how to use list to materialize sequences, you can write more flexible and robust Jinja code.nn