Durch Kommas getrennte Listen in Django-Vorlagen

Wenn fruitsist die Liste ['apples', 'oranges', 'pears'],

Gibt es eine schnelle Möglichkeit, mit Django-Vorlagen-Tags "Äpfel, Orangen und Birnen" herzustellen?

Ich weiß, dass es nicht schwierig ist, dies mit einer Schleife und {% if counter.last %}Anweisungen zu tun , aber da ich dies wiederholt verwenden werde, denke ich, dass ich lernen muss, wie man benutzerdefinierte Anweisungen schreibtStichworte Filter, und ich möchte das Rad nicht neu erfinden, wenn es bereits getan wurde.

Als Erweiterung sind meine Versuche, das Oxford-Komma fallen zu lassen (dh "Äpfel, Orangen und Birnen" zurückzugeben), noch chaotischer.

Erste Wahl: Verwenden Sie das vorhandene Tag für Verknüpfungsvorlagen.

http://docs.djangoproject.com/de/dev/ref/templates/builtins/#join

Hier ist ihr Beispiel

{{ value|join:" // " }}

Zweite Wahl: Mach es in der Ansicht.

fruits_text = ", ".join( fruits )

Stellen Sie fruits_textdie Vorlage zum Rendern bereit.

Hier ist eine super einfache Lösung. Fügen Sie diesen Code in comma.html ein:

{% if not forloop.last %}{% ifequal forloop.revcounter 2 %} and {% else %}, {% endifequal %}{% else %}{% endif %}

Und jetzt, wo immer Sie das Komma setzen würden, fügen Sie stattdessen "comma.html" hinzu:

{% for cat in cats %}
Kitty {{cat.name}}{% include "comma.html" %}
{% endfor %}

Update: @ user3748764 gibt uns eine etwas kompaktere Version ohne die veraltete ifequal-Syntax:

{% if not forloop.first %}{% if forloop.last %} and {% else %}, {% endif %}{% endif %}

Beachten Sie, dass es vor dem Element und nicht nach dem Element verwendet werden sollte.

Ich würde eine benutzerdefinierte vorschlagen django Templating Filter anstelle eines benutzerdefinierten Tag - Filter ist handlicher und einfacher (gegebenenfalls wie hier). {{ fruits | joinby:", " }}sieht aus wie das, was ich für diesen Zweck haben möchte ... mit einem benutzerdefinierten joinbyFilter:

def joinby(value, arg):
    return arg.join(value)

Was, wie Sie sehen, die Einfachheit selbst ist!

Auf der Django-Vorlage ist dies alles, was Sie tun müssen, um nach jeder Frucht ein Komma zu setzen. Das Komma hört auf, sobald es die letzte Frucht erreicht hat.

{% if not forloop.last %}, {% endif %}

Hier ist der Filter, den ich geschrieben habe, um mein Problem zu lösen (er enthält kein Oxford-Komma).

def join_with_commas(obj_list):
    """Takes a list of objects and returns their string representations,
    separated by commas and with 'and' between the penultimate and final items
    For example, for a list of fruit objects:
    [<Fruit: apples>, <Fruit: oranges>, <Fruit: pears>] -> 'apples, oranges and pears'
    """
    if not obj_list:
        return ""
    l=len(obj_list)
    if l==1:
        return u"%s" % obj_list[0]
    else:    
        return ", ".join(str(obj) for obj in obj_list[:l-1]) \
                + " and " + str(obj_list[l-1])

So verwenden Sie es in der Vorlage: {{ fruits|join_with_commas }}

Wenn Sie ein '.' Verwenden Sie am Ende der Antwort von Michael Matthew Toomim:

{% if not forloop.last %}{% ifequal forloop.revcounter 2 %} and {% else %}, {% endifequal %}{% else %}{% endif %}{% if forloop.last %}.{% endif %}

Alle Antworten hier schlagen eine oder mehrere der folgenden fehl:

• Sie schreiben etwas (schlecht!) Um, das in der Standardvorlagenbibliothek enthalten ist (ack, top answer!)
• Sie werden nicht andfür den letzten Artikel verwendet.
• Ihnen fehlt ein serielles (Oxford) Komma.
• Sie verwenden eine negative Indizierung, die für Django-Abfragesätze nicht funktioniert.
• Sie handhaben normalerweise die Saitenhygiene nicht richtig.

Hier ist mein Eintrag in diesen Kanon. Zunächst die Tests:

class TestTextFilters(TestCase):

    def test_oxford_zero_items(self):
        self.assertEqual(oxford_comma([]), '')

    def test_oxford_one_item(self):
        self.assertEqual(oxford_comma(['a']), 'a')

    def test_oxford_two_items(self):
        self.assertEqual(oxford_comma(['a', 'b']), 'a and b')

    def test_oxford_three_items(self):
        self.assertEqual(oxford_comma(['a', 'b', 'c']), 'a, b, and c')

Und jetzt der Code. Ja, es wird ein bisschen chaotisch, aber Sie werden sehen, dass keine negative Indizierung verwendet wird:

from django.utils.encoding import force_text
from django.utils.html import conditional_escape
from django.utils.safestring import mark_safe

@register.filter(is_safe=True, needs_autoescape=True)
def oxford_comma(l, autoescape=True):
    """Join together items in a list, separating them with commas or ', and'"""
    l = map(force_text, l)
    if autoescape:
        l = map(conditional_escape, l)

    num_items = len(l)
    if num_items == 0:
        s = ''
    elif num_items == 1:
        s = l[0]
    elif num_items == 2:
        s = l[0] + ' and ' + l[1]
    elif num_items > 2:
        for i, item in enumerate(l):
            if i == 0:
                # First item
                s = item
            elif i == (num_items - 1):
                # Last item.
                s += ', and ' + item
            else:
                # Items in the middle
                s += ', ' + item

    return mark_safe(s)

Sie können dies in einer Django-Vorlage verwenden mit:

{% load my_filters %}
{{ items|oxford_comma }}

Ich würde es einfach verwenden, ', '.join(['apples', 'oranges', 'pears'])bevor ich es als Kontextdaten an die Vorlage sende.

AKTUALISIEREN:

data = ['apples', 'oranges', 'pears']
print(', '.join(data[0:-1]) + ' and ' + data[-1])

Sie erhalten eine apples, oranges and pearsAusgabe.

Django hat keine Unterstützung für diesen Out-of-the-Box. Sie können hierfür einen benutzerdefinierten Filter definieren:

from django import template


register = template.Library()


@register.filter
def join_and(value):
    """Given a list of strings, format them with commas and spaces, but
    with 'and' at the end.

    >>> join_and(['apples', 'oranges', 'pears'])
    "apples, oranges, and pears"

    """
    # convert numbers to strings
    value = [str(item) for item in value]

    if len(value) == 1:
        return value[0]

    # join all but the last element
    all_but_last = ", ".join(value[:-1])
    return "%s, and %s" % (all_but_last, value[-1])

Wenn Sie sich jedoch mit etwas Komplexerem als nur Listen von Zeichenfolgen befassen möchten, müssen Sie {% for x in y %}in Ihrer Vorlage eine explizite Schleife verwenden.

Wenn Sie Einzeiler mögen:

@register.filter
def lineup(ls): return ', '.join(ls[:-1])+' and '+ls[-1] if len(ls)>1 else ls[0]

und dann in der Vorlage:

{{ fruits|lineup }}

Ich denke, die einfachste Lösung könnte sein:

@register.filter
def comma_list(p_values: Iterable[str]) -> List[str]:
    values = list(p_values)
    if len(values) > 1:
        values[-1] = u'and %s' % values[-1]
    if len(values) > 2:
        return u', '.join(values)
    return u' '.join(values)