Numérique pour la boucle dans modèles Django

Comment puis-je écrire un numérique for boucle dans un Django template? Je veux dire quelque chose comme

for i = 1 to n

InformationsquelleAutor Lev | 2009-07-10

django django-templates

370

J'ai utilisé une technique simple qui fonctionne très bien pour de petites affaires sans balises spéciales et aucun autre contexte. Parfois, cela est très pratique
```
{% for i in '0123456789'|make_list %}
    {{ forloop.counter }}
{% endfor %}
```
- D'accord. Ils devraient construire cette dans.
- FWIW, 012 == 12, donc il ne boucle plus de 1 et 2.
- {% for i in '0123456789'|make_list %} pour itérer sur l'ensemble des 10, de ne pas sauter de 0.
- très intelligent. quid d'une compréhension de liste bien? Genre de se prend le hackishness, mais utilise la même idée x = 5, y=[i for i in range(x)] contexte={'iterateover':y}
- range(x)} va fonctionner tout aussi bien
- Cette solution ne fonctionne pas lorsque la chaîne est de longueur variable, je veux dire quand vous ne savez pas à l'avance sa longueur.
- Il est juste dommage que Django devs n'ont pas encore d'un filtre pour le faire (comme la gamme, fi).
- Générer une chaîne de caractères de longueur arbitraire avec "rjust' {% for i in "x"|rjust:"100" %}
- Pour la 3ème fois, cette réponse EST MAUVAIS. Ne PAS utiliser ce. L'utilisation d'une balise de modèle et de le faire correctement. Je ne vois pas comment dire, la réponse est mauvaise, est une raison suffisante pour supprimer un commentaire.
- Qu'est-ce que le si mal avec cela? Assurez-vous qu'il est hacky, mais l'ajout d'une balise de modèle juste parce que vous avez besoin de faire une boucle sur une petite plage pour une fois dans un projet n'est pas une grande aussi des solutions.
- profitez de comptage " x
- Comment cette réponse ont donc beaucoup de upvotes? Je suis d'accord avec @Cér, c'est une idée terrible...
- À mon avis c'est une mauvaise solution en tant que gars dit ci-dessus... je ne le permettrait pas si je ferais de la revue de code @Cér
- Ce n'est pas mauvais, mais Django est inutile, limité par l'absurde système de template est.
- De moins de 4 forcycle n'est pas un travail. Filtre de retour de chaîne de longueur minimale.
InformationsquelleAutor Udi
97

Malheureusement, c'est pas pris en charge dans le langage de template de Django. Il y a un couple de suggestions, mais ils semblent un peu complexes. Je voudrais juste mettre une variable dans le contexte:
```
...
render_to_response('foo.html', {..., 'range': range(10), ...}, ...)
...
```
et dans le modèle:
```
{% for i in range %}
     ...
{% endfor %}
```
- Les motivations de l'Django auteurs avaient pour réfuter la plaine de python dans les modèles semblent inutiles et sans importance par rapport à la douleur et la perte de temps impliquées dans le travail autour de ne pas avoir, de ne pas mentionner la nécessité d'inventer une toute nouvelle langue quand un parfaitement impressionnant (python!) est déjà là!
- Si c'est ce que vous voulez, il suffit d'utiliser Jinja2: docs.djangoproject.com/en/1.9/topics/templates/...
InformationsquelleAutor tghw
96
```
{% with ''|center:n as range %}
{% for _ in range %}
    {{ forloop.counter }}
{% endfor %}
{% endwith %}
```
- Grande réponse. Fonctionne parce que le centre de crée une chaîne de n espaces qui sont alors en boucle sur. Chaque espace char est alors ignoré, mais la valeur actuelle dans la gamme peut être trouvé à partir de forloop.compteur (ou forloop.counter0). Voir docs.djangoproject.com/en/dev/ref/templates/builtins/#center
- Super réponse! Ne pas avoir à créer un nouveau filtre.
- Pas besoin de faire quoi que ce soit dans la vue. Excellent hack
InformationsquelleAutor Tomasz Żyźniewski
72

Mon point de vue sur cette question, je pense que c'est le plus beau. Je garde un my_filters.py sur le templatetags répertoire.
```
@register.filter(name='times') 
def times(number):
    return range(number)
```
Et vous l'utiliser comme ceci:
```
{% load my_filters %}
{% for i in 15|times %}
    <li>Item</li>
{% endfor %}
```
- Je pense que c'est une bonne solution. Ne range(1, 16) obtenir des nombres à partir de 1 et non 0.
- Également créer un fichier vide _ init _.py dans templatetags répertoire. Également ajouter ces ligne vers le haut de la my_filters.py from django.template import Library;register = Library()
- Ajouter un second paramètre de filtre et vous obtenez la gamme complète de la fonction construite en python. @register.filter(name='range') def filter_range(start, end): return range(start, end) Obtient alors utilisé comme {% for i in 1|range:6 %}{% endfor %}. Voir la réponse ci-dessous....
- J'ai modifié un peu (excusez la mise en forme): try: return range(number) except: return []. De cette façon, il n'élève jamais une erreur et renvoie un tableau vide (similaire à la façon dont la plupart des modèle de fonctions de travail).
InformationsquelleAutor Guillermo Siliceo Trueba
38

Peut-être comme cela?
```
{% for i in "x"|rjust:"100" %}
...
{% endfor %}
```
InformationsquelleAutor CruelSilence
36

Vous pouvez passer d'une liaison de
```
{'n' : range(n) }
```
pour le modèle, puis faire
```
{% for i in n %}
...
{% endfor %}
```
Note que vous obtiendrez de 0 basée sur le comportement (0, 1, ... n-1).

(Mis à jour pour Python3 de compatibilité)
- Utilisation range(n) en python 3, si je me souviens correctement, xrange était obsolète sur elle
- En effet oui. Et c'était l'une des deux lignes de code que j'ai eu de la chance dans la transition d'une application pour Python3.
InformationsquelleAutor Dave W. Smith
9

Vous ne passez pas n lui-même, mais plutôt range(n) [la liste des entiers de 0 à n-1], à partir de votre point de vue à votre modèle, et dans le second, vous ne {% for i in therange %} (si vous en avez absolument insister sur 1 plutôt que la normal 0 index de base vous pouvez utiliser forloop.counter dans la boucle du corps;-).

InformationsquelleAutor Alex Martelli

Juste au cas où quelqu'un d'autre vient à travers cette question... j'ai créé un modèle de balise qui permet de créer un range(...): http://www.djangosnippets.org/snippets/1926/

Accepte les mêmes arguments que la "gamme" builtin et crée une liste contenant 
le résultat de la "gamme". 

Syntaxe: 
{% mkrange [démarrer,] stop[, pas] comme context_name %} 

Par exemple: 
{% mkrange 5 10 2 some_range %} 
{% for i in some_range %} 
{{ i }}: quelque Chose que je veux répéter\n 
{% finpour %} 

Produit: 
5: quelque Chose que je veux répéter 
7: quelque Chose que je veux répéter 
9: quelque Chose que je veux répéter

-1 en faveur de Alex Pi extrait de code qui ajoute le support de la variable d'arguments.

InformationsquelleAutor David Wolever

Vous devez utiliser "tranche" dans le modèle, un exemple, comme ceci:

dans views.py

contexts = {
    'ALL_STORES': Store.objects.all(),
}

return render_to_response('store_list.html', contexts, RequestContext(request, processors=[custom_processor]))

dans store_list.html:

<ul>
{% for store in ALL_STORES|slice:":10" %}
    <li class="store_item">{{ store.name }}</li>
{% endfor %}
</ul>

Vous ne savez pas si c'est ce que l'OP a été à la recherche pour, mais c'est exactement ce que je cherchais. =)

InformationsquelleAutor Vinta

Cette méthode prend en charge toutes les fonctionnalités de la norme range([start,] stop[, step]) fonction

<app>/templatetags/range.py

from django import template

register = template.Library()


@register.filter(name='range')
def _range(_min, args=None):
    _max, _step = None, None
    if args:
        if not isinstance(args, int):
            _max, _step = map(int, args.split(','))
        else:
            _max = args
    args = filter(None, (_min, _max, _step))
    return range(*args)

Utilisation:

{% load range %}

<p>stop 5
{% for value in 5|range %}
{{ value }}
{% endfor %}
</p>

<p>start 5 stop 10
{% for value in 5|range:10 %}
{{ value }}
{% endfor %}
</p>

<p>start 5 stop 10 step 2
{% for value in 5|range:"10,2" %}
{{ value }}
{% endfor %}
</p>

Sortie

<p>stop 5
0 1 2 3 4
</p>

<p>start 5 stop 10
5 6 7 8 9
</p>

<p>start 5 stop 10 step 2
5 7 9
</p>

InformationsquelleAutor Rebs

7

J'ai essayé très dur sur cette question, et je trouve que la meilleure réponse ici:
(à partir de comment faire une boucle 7 fois dans les modèles django)

Vous pouvez même accéder au idx!

views.py:
```
context['loop_times'] = range(1, 8)
```
html:
```
{% for i in loop_times %}
        <option value={{ i }}>{{ i }}</option>
{% endfor %}
```
InformationsquelleAutor KKlalala
5

Vous pouvez passer :

{ 'n' : range(n) }

À utiliser un modèle :

{% for i in n %}
...
{% finpour %}
- lisible et simple, facile à comprendre ce qui se passe si vous êtes le gars à côté, le maintien du code
InformationsquelleAutor rkoots
4

Je suis juste en prenant de la réponse un peu plus loin et de le rendre plus robuste. Cela vous permet de spécifier n'importe quel point de départ, donc 0 ou 1 par exemple. Il utilise aussi un python de gamme disposent d'où la fin est un de moins de sorte qu'il peut être utilisé directement avec la liste des longueurs par exemple.
```
@register.filter(name='range')
def filter_range(start, end):
  return range(start, end)
```
Puis dans votre modèle d'inclure le modèle ci-dessus de la balise de fichier et utiliser les éléments suivants:
```
{% for c in 1|range:6 %}
{{ c }}
{% endfor %}
```
Maintenant vous pouvez le faire 1 à 6 au lieu de simplement 0-6 ou codage en dur elle. L'ajout d'une étape nécessiterait une balise de modèle, ce qui devrait couvrir plus de cas d'utilisation c'est donc un pas en avant.
- C'est une extension de @guillermo-siliceo-trueba réponse.
InformationsquelleAutor Paul Kenjora
3

Vous pouvez utiliser:
{% with ''|center: i as range %}
- Pouvez-vous donner un exemple/explication de la façon dont cela fonctionne?
InformationsquelleAutor rkoots
3

Cela nécessite une range fonction. Une feature de Django billet a été soulevée (https://code.djangoproject.com/ticket/13088) pour cela, mais fermé comme "ne sera pas corrigé" avec le commentaire suivant.

Mon impression de cette idée est qu'il est en train de conduire à la programmation dans le modèle. Si vous avez une liste d'options qui doivent être rendus, ils doivent être calculées de la vue, et non pas dans le modèle. Si c'est aussi simple que d'une plage de valeurs, alors ainsi soit-il.

Ils ont un bon point de Modèles sont censés être très simples représentations de la vue. Vous devez créer le peu de données nécessaires dans la vue et de passer pour le modèle dans le contexte.
- La vue doit être pour les données, le modèle devrait être pour la présentation. Le point de vue ne devrait pas nécessiter de connaissance du contenu du modèle, spécifiquement gammes. Django est la raison pour ignorer ces demandes de fonctionnalités est de proférer des âneries.
InformationsquelleAutor Alastair McCormack
0

Si le nombre est à venir à partir d'un modèle, j'ai trouvé ceci pour être un bon patch pour le modèle:
```
def iterableQuantity(self):
    return range(self.quantity)
```
- Ne savez pas pourquoi vous obtenez vers le bas voté, c'est une réponse valable. Je n'aime pas cette solution par rapport à la mise en œuvre d'un véritable filtre que j'ai fourni ci-dessus. DB modèles doivent être conservés maigre. Mais c'est toujours mieux que la majorité a accepté de répondre.
- Je ne sais même pas...
- Je suis 9 ans trop tard, mais je upvoted vous de la gpa, ne vous inquiétez pas à ce sujet.
InformationsquelleAutor Alper

Vous devez vous connecter pour publier un commentaire.