Iterating through two lists in Django templates

You can use zip in your view:

mylist = zip(list1, list2) context = { 'mylist': mylist, } return render(request, 'template.html', context) 

and in your template use

{% for item1, item2 in mylist %} 

to iterate through both lists.

This should work with all version of Django.

Simply define zip as a template filter:

@register.filter(name='zip') def zip_lists(a, b): return zip(a, b) 

Then, in your template:

{%for a, b in first_list|zip:second_list %} {{a}} {{b}} {%endfor%} 

I built django-multiforloop to solve this problem. From the README:

With django-multiforloop installed, rendering this template

{% for x in x_list; y in y_list %} {{ x }}:{{ y }} {% endfor %} 

with this context

context = { "x_list": ('one', 1, 'carrot'), "y_list": ('two', 2, 'orange') } 

will output

one:two 1:2 carrot:orange 

In views.py:

foo = ['foo', 'bar'] moo = ['moo', 'loo'] zipped_list = zip(foo,moo) return render(request,"template.html",{"context":zipped_list} 

In template.html:

{% for f,m in context%} {{f}}{{m}} {% endfor %} 

If f is a queryset returned from database then access it by {{f.required_attribute_name}}

You can make the foo objects properties of the moo objects on the server side.

for f, b in zip(foo, bar): f.foosBar = b context = { "foo": foo } 

This is especially clean when the second list are properties of the first (which is typically the case).

users = User.objects.all() for user in users: user.bestFriend = findBestFriendForUser(user) context = { "users": users } 

Here is modified {% for %} templatetag which allows iterating several lists at once izip-ing them before:

import re from itertools import izip from django import template from django.template.base import TemplateSyntaxError from django.template.defaulttags import ForNode register = template.Library() class ZipExpression(object): def __init__(self, var): self.var = var def resolve(self, *args, **kwargs): return izip(*( f.resolve(*args, **kwargs) for f in self.var )) @register.tag('for') def do_for(parser, token): """ For tag with ziping multiple iterables. """ bits = token.contents.split() if len(bits) < 4: raise TemplateSyntaxError("'foreach' statements should have at least" " four words: %s" % token.contents) is_reversed = False try: in_index = bits.index('in') sequence = bits[in_index+1:] if sequence[-1] == 'reversed': is_reversed = True sequence.pop() if not sequence or 'in' in sequence: raise ValueError sequence = re.split(r' *, *', ' '.join(sequence)) except ValueError: raise TemplateSyntaxError( "'foreach' statements should use the format" " 'foreach a,b,(...) in x,y,(...)': %s" % token.contents) loopvars = re.split(r' *, *', ' '.join(bits[1:in_index])) for var in loopvars: if not var or ' ' in var: raise TemplateSyntaxError("'foreach' tag received an invalid" " argumewnt: %s" % token.contents) if len(sequence) > 1: sequence = ZipExpression(map(parser.compile_filter, sequence)) else: sequence = parser.compile_filter(sequence[0]) nodelist_loop = parser.parse(('empty', 'endfor',)) token = parser.next_token() if token.contents == 'empty': nodelist_empty = parser.parse(('endfor',)) parser.delete_first_token() else: nodelist_empty = None return ForNode( loopvars, sequence, is_reversed, nodelist_loop, nodelist_empty) 

Just save it as templatetag library and import it in your template. It will override build-in {% for %} tag (don't worry it is backward compatible with it).

Example usage:

{% for a,b in foo, moo %} {{ a }} {{ b }} {% endfor %} 

@marco's approach, using zip in a custom template filter, works well for the OP's case with two lists.

However, a template filter only supports two arguments, so, if you want to combine more than two lists, you would need to resort to filter chaining.

As an alternative, you could create a simple_tag, which supports any number of arguments.

For example:

@register.simple_tag(name='zip') def zip_many(*args): return zip(*args) 

This can be used in a template as follows:

{% zip a b c as abc_zipped %} {% for x, y, z in abc_zipped %} ... {% endfor %} 

where a, b, and c are lists.