Compteur de modèles Django dans les boucles imbriquées

Salut j'ai une liste de deux dictionnaires, je suis de passage à un modèle Django:

base_parts = [
    {'important item': 43},
    {'lesser item': 22, 'lesser item': 3, 'lesser item': 45}
]

dans mon template je peux le faire:

{% for base_part in base_parts %}
    {% for k, v in base_part.items %}

    {# ...do stuff #}

    {# I try to get a running total of items to use as an ID #}
    inner ID: {% forloop.counter0 %}< br/>
    outer ID: {% forloop.parentloop.counter0 %}< br/>

    {% endfor %}
{% endfor %}

Comme vous pouvez le voir, ce que je veux, c'est un total cumulé du nombre total de points que j'ai itérer, mais les deux méthodes que j'ai inclus le retour des doublons. Je sais que je peut concaténer les boucles, mais je suis à l'aide d'un formset et voudrais vraiment les id pour être indexé 0,1,2...etc.

Est-il un moyen de parvenir à ce type de compter dans le modèle?

Toute aide appréciée.

MODIFIER

de sortie pour le moment ressemble à:

outerID: 0<br />
innerID: 0<br />
outerID: 0<br />
innerID: 1<br />
outerID: 1<br />
innerID: 0<br />
outerID: 1<br />
innerID: 1<br />
outerID: 1<br />
innerID: 2<br />

Je veux:

totalID: 0<br />
totalID: 1<br />
totalID: 2<br />
totalID: 3<br />
totalID: 4<br />
totalID: 5<br />
totalID: 6<br />
totalID: 7<br />
totalID: 8<br />
totalID: 9<br />

source d'informationauteur Darwin Tech

django django-templates

J'ai trouvé une meilleure solution itertools. (Mieux que ma précédente réponse)
Vous pouvez régler l'état de la boucle de la itertools variable envoyé à la vue du contexte.
Cette fois j'ai essayé sur un mannequin projet Django et il fonctionne comme un charme.

views.py:

from django.shortcuts import render_to_response
import itertools

def home(request):
    iterator=itertools.count()
    base_parts = [
        {'important item': 43},
        {'lesser item1': 22, 'lesser item2': 3, 'lesser item3': 45},
        {'most important item': 55}
    ]
    return render_to_response('index.html', 
                             {'base_parts': base_parts, 'iterator':iterator})

index.html:

{% for base_part in base_parts %}
    {% for k, v in base_part.items %}
        {{ iterator.next }} - {{ v }}<br/>
    {% endfor %}
{% endfor %}

HTML de Sortie:

Triés valeurs:

(Cette partie n'est pas une réponse à la question. C'est plus comme je suis en train de jouer autour)

Vous pouvez utiliser Django SortedDict au lieu de Python dictionnaire intégré pour conserver les éléments de commande.

views.py

from django.shortcuts import render_to_response
import itertools
from django.utils.datastructures import SortedDict

def home(request):
    iterator=itertools.count()
    base_parts = [
        SortedDict([('important item', 43)]),
        SortedDict([('lesser item1', 22), 
                    ('lesser item2', 3), 
                    ('lesser item3', 45)]),
        SortedDict([('most important item', 55)])
    ]
    print base_parts[1]
    return render_to_response('index.html', 
                             {'base_parts': base_parts, 'iterator':iterator})

HTML de Sortie:

Edition 2014-Mai-25

Vous pouvez également utiliser les collections.OrderedDict au lieu de Django SortedDict.

Modifier 2016-Juin-28

Appel iterator.next ne fonctionne pas en Python 3. Vous pouvez créer votre propre classe iterator, héritant de itertools.count:

import itertools
class TemplateIterator(itertools.count):
    def next(self):
        return next(self)

3

Dans un monde idéal, vous devriez éviter de mettre ce genre de logique dans le modèle. Si vous n'êtes pas à préserver la hiérarchie de votre sortie (par exemple, l'affichage de ces éléments sous la forme d'une liste de listes) déplier la liste et l'utilisation d'une simple boucle for et le compteur de la boucle.

Cependant, la solution idéale n'est pas toujours une option. En théorie, je crois que ce qui suit pourrait/devrait fonctionner
```
{% for base_part in base_parts %}     
    {% with outerCount = forloop.parentloop.counter0 %}
    {% for k, v in base_part.items %}
        ...
        {% with innerCounter = forloop.counter %}
        {{ outerCounter|add:innerCounter }}
    {% endfor %}
{% endfor %}
```
1

Mise à JOUR: Ce n'est pas une réponse correcte. Je suis juste le garder ici pour afficher ce n'est pas travail.

Je dois avouer que je n'ai pas essayé celui-ci, mais vous pouvez utiliser avec et ajouter consolidés.
```
{% with total=0 %}
    {% for base_part in base_parts %}
        {% for k, v in base_part.items %}

        {# ...do stuff #}

        {# I try to get a running total of items to use as an ID #}
        totalId: {{ total|add:"1" }} <br/>
        {% endfor %}
    {% endfor %}
{% endwith %}
```
Ce serait probablement de travail sur le modèle de niveau mais je pense que la meilleure approche est de calculer le niveau d'affichage de la et le passage d'un dictionnaire pour le modèle qui comprend les valeurs calculées.

Il serait tout à fait et efficace de le faire à la vue de code...

    #Calculate the count
    count = 0
    for item in base_parts:
       count+=len(item.keys())

    run_range = range(count)

    return to the template

    #template
    {% for x in run_range|slice:'1' %}
    {{x}}
    {% endfor %}

0

Alors j'ai juste ajouté le dictionnaire des éléments à une liste, en s'assurant que celui que je voulais, c'était d'abord:
```
base_parts = []
for k, v in rails_dic.items():
    base_parts.append({k: v})
for k, v in accessories_dic.items():
    base_parts.append({k: v})
```
Cela peut ne pas être la meilleure façon de le faire, et je suis ouvert à un plus pythonic manière que le réponse correcte.

Je pense que le fait de prendre soin de cela dans le modèle est à la fois difficile et ne convient pas. C'est pourquoi je ma pas accepter ces réponses. Je voudrais qu'à l'avenir, les visiteurs peuvent voir que la solution a été demandé pour l'ensemble du problème dans la plus correcte, et pas seulement la façon de pirater dans les modèles.

Vous devez vous connecter pour publier un commentaire.