Use [`length` filter](https://docs.djangoproject.com/en/dev/ref/templates/builtins/?from=olddocs#length):

    {{ some_list|length }}

Use `list|length`. `|` indicates that you will use a filter. The size of the list is 

    {{ list|length }}

    {% if your_list %}
    {{ your_list|length }}
    {% endif %}

Just remember that if your_list is a property it will be tigger on this line, so if you make dynamic list that is created each time you ask for it and you want to `for` later you will trigger it twice;

Just a little update in case someone ends up here. As pointed in the comments, if you have a QuerySet, now it&#39;s possible to get the length with:

    {{ your_list.count }}

Hope it helps!

I have a lot of this kind of string and I want to find a command to convert it in ascii, I tried with `echo -e` and `od`, but it did not work.

    0xA7.0x9B.0x46.0x8D.0x1E.0x52.0xA7.0x9B.0x7B.0x31.0xD2

Conversion hex string into ascii in bash command line

This seems like something that would have a quick answer, but I can&#39;t find one. Maybe I&#39;m searching the wrong terms? No libraries please, though I don&#39;t need cross-browser fallbacks, I&#39;m targeting all the latest versions on this project. 

I&#39;m getting some elements:

    element = document.querySelectorAll(&quot;.someselector&quot;);

This is working, but how do I now delete these elements? Do I have to loop through them and do the `element.parentNode.removeChild(element);` thing, or is there a simple function I&#39;m missing?

How to remove elements that were fetched using querySelectorAll?

Simple question. I have a list in my template and want to output the length of the list. Do I have to calculate this in my view and hand it over via my context?
 

    &lt;p&gt;the size of the list is {{??}}&lt;/p&gt;

    {% for element in list %}
    &lt;p&gt;element.Name&lt;/p&gt;
    {% end for %}
  
    

 

Django access the length of a list within a template

Simple question. I have a list in my template and want to output the length of the list. Do I have to calculate this in my view and hand it over via my context?
<pre><code class="hljs language-css">&#x3C;p>the size of the list is {{??}}&#x3C;/p>

{% for element in list %}
&#x3C;p>element.Name&#x3C;/p>
{% end for %}

</code></pre>

I have two models defined loosely like this:

    class InformationUnit(models.Model):
        username = models.CharField(max_length=255)
        project = models.ForeignKey(&#39;Project&#39;)
        ...
    
    class Project(models.Model):
        name = models.CharField(max_length=255)

Now, in a view, I want to annotate all the `InformationUnit`s that belong to a project, so I do this:

    p = Project.objects.all().annotate(Count(&#39;informationunit&#39;)

which works just ok.

Furthermore, I want to know, in each project, how many distinct `username`s participate.
That is, count how many distinct `username`s are there in the `InformationUnit`s that compose one project. 
I have tried the following, but it simply counts the number of `InformationUnit`, regardless of the `username`:

    p = Project.objects.all().annotate(Count(&#39;informationunit__username&#39;)

Note that `username` is not an object, it is a string. Is there a clean way to do this or should I create a more complicated code based on loops and spaghetti code :P

Thanks a lot!

Django annotate count with a distinct field

A lot of Django app deployments over Amazon&#39;s EC2 use HTTP servers NGINX and Gunicorn. 

I was wondering what they actually do and why both are used in parallel. What is the purpose of running them both in parallel?

What is the purpose of NGINX and Gunicorn running in parallel?

Hi I have an infuriating problem.

I have a url pattern like this:

    # mproject/myapp.urls.py
    
    url(r&#39;^project/(?P&lt;project_id&gt;\d+)/$&#39;,&#39;user_profile.views.EditProject&#39;,name=&#39;edit_project&#39;),

it works fine in the browser but for testing, when I do this in the shell:

    from django.test import Client
    from django.core.urlresolvers import reverse

    client= Client()
    response = client.get(reverse(&#39;edit_project&#39;), project_id=4)

I get the dreaded:

    NoReverseMatch: Reverse for &#39;edit_project&#39; with arguments &#39;()&#39; and keyword arguments &#39;{}&#39; not found.


What am I missing here? 

Django Reverse with arguments &#39;()&#39; and keyword arguments &#39;{}&#39; not found

Which is it better to use generally?

 - https://docs.djangoproject.com/en/dev/topics/http/shortcuts/#redirect

 - https://docs.djangoproject.com/en/dev/ref/request-response/#django.http.HttpResponseRedirect

Is there any advantage to writing:

    return redirect(my_url)

over:

    return HttpResponseRedirect(my_url)

Or is it a direct alias? Is there any difference? Which is more pythonic/django-nic?

What the difference between using Django redirect and HttpResponseRedirect?

Let&#39;s pretend I have the following QueryDict: 

    &lt;QueryDict: {u&#39;num&#39;: [0], u&#39;var1&#39;: [u&#39;value1&#39;, u&#39;value2&#39;], u&#39;var2&#39;: [u&#39;8&#39;]}&gt;

I&#39;d like to have a dictionary out of this, eg:

    {&#39;num&#39;: [0], &#39;var1&#39;:[&#39;value1&#39;, &#39;value2&#39;], &#39;var2&#39;:[&#39;8&#39;]}

(I don&#39;t care if the unicode symbol `u` stays or goes.)

If I do `queryDict.dict()`, as suggested by the [django site][1], I lose the extra values belonging to `var1`, eg:

    {&#39;num&#39;: [0], &#39;var1&#39;:[&#39;value2&#39;], &#39;var2&#39;:[&#39;8&#39;]}

I was thinking of doing this:

    myDict = {}
    for key in queryDict.iterkeys():
        myDict[key] = queryDict.getlist(key)

Is there a better way? 


  [1]: https://docs.djangoproject.com/en/dev/ref/request-response/#django.http.QueryDict.dict

How to change a django QueryDict to Python Dict?

(If you&#39;re a C++11 pro, skip to the bold paragraph.)

Let&#39;s say I want to write a template method which calls and returns the result of a passed object which type is the template parameter:

    template&lt;ReturnType, T&gt;
    ReturnType doSomething(const T &amp; foo) {
        return foo.bar(); // EDIT: Might also be an expression introducing a temp val
    }

So `T` has to have a method `ReturnType T::bar() const` in order to be used in a call like this:

    struct MyClass {
        ...
        int bar() const;
        ...
    };
    ...
    MyClass object;
    int x = doSomething&lt;int, MyClass&gt;(object);
    
We don&#39;t have to write `MyClass` thanks to type deduction and the call becomes:

    int x = doSomething&lt;int&gt;(object);

But omitting `&lt;int&gt;` too results in a compilation error because the method doesn&#39;t require to return int in order to be assigned to `x` afterwards (it could return `char` for example).

In C++0x/11 we have the `auto` and `decltype` with which we can use to deduce the return type of a template method:

    template&lt;T&gt;
    auto doSomething(const T &amp; foo) -&gt; decltype(foo.bar()) {
        return foo.bar(); // EDIT: Might also be an expression introducing a temp val
    }

The compiler will now find out what the type of `foo.bar()` is and just uses this as the return type. With our concrete class `MyClass` this will be an `int` and the following would suffice:

    int x = doSomething(object);

**Now to my question:**

If MyClass defines `bar()` as returning an `int&amp;`, the return type of `doSomething(object)` will also be an `int&amp;` = `decltype(foo.bar())`. This is a problem, since as G++ now complies that I&#39;m *returning reference to temporary*.

How can I fix this? Is there something like `remove_reference` which can be used like `remove_reference(decltype(foo.bar()))`?

I thought about just declaring a helper method which takes a `T&amp;` and returns a `T` and then define the return type of `doSomething` to be `decltype(helper(foo.bar()))`. But there has to be a better way, I&#39;m feeling it.

Remove reference in decltype (return T instead of T&amp; where T&amp; is the decltype)

Basically, what I want to be able to do is take a lambda with any number of any type of parameters and convert it to an std::function.
I&#39;ve tried the following and neither method works.

    std::function([](){});//Complains that std::function is missing template parameters
    template &lt;typename T&gt; void foo(function&lt;T&gt; f){}
    foo([](){});//Complains that it cannot find a matching candidate

The following code does work however, but it is not what I want because it requires explicitly stating the template parameters which does not work for generic code.

    std::function&lt;void()&gt;([](){});

I&#39;ve been mucking around with functions and templates all evening and I just can&#39;t figure this out, so any help would be much appreciated.

As mentioned in a comment, the reason I&#39;m trying to do this is because I&#39;m trying to implement currying in C++ using variadic templates. Unfortunately, this fails horribly when using lambdas. For example, I can pass a standard function using a function pointer.

    template &lt;typename R, typename...A&gt;
    void foo(R (*f)(A...)) {}
    void bar() {}
    int main() {
        foo(bar);
    }

However, I can&#39;t figure out how to pass a lambda to such a variadic function. Why I&#39;m interested in converting a generic lambda into an std::function is because I can do the following, but it ends up requiring that I explicitly state the template parameters to std::function which is what I am trying to avoid.

    template &lt;typename R, typename...A&gt;
    void foo(std::function&lt;R(A...)&gt;) {}
    int main() {
        foo(std::function&lt;void()&gt;([](){}));
    }
    

How to convert a lambda to an std::function using templates

Are there any guidelines on how C++ templates and template meta-functions should be documented with Doxygen?

For example:

    /// @brief metafunction for generation of a map of message types to
    /// their associated callbacks.
    /// @tparam Seq the list of message types
    template&lt; class Seq &gt;
    struct generate_callback_map
    {
        typedef typename mpl::transform&lt; Seq
                                       , build_type_signature_pair&lt; mpl::_1 &gt; 
                                       &gt;::type vector_pair_type;
        typedef typename fusion::result_of::as_map&lt; vector_pair_type &gt;::type type;
    };

So far I have seen the following suggestions:

 - `@tparam` used to document template parameters.
 - `@arg` alternative way of documenting template parameters.
 - `@brief` used to describe the metafunction.

How should the &#39;returned type&#39; for the metafunction be documented? 

Does anyone have any good suggestions or personal preferences for using Doxygen with C++ templates?

How to document C++ templates and template metafunctions with doxygen?

Suppose I have a template function and two classes

    class animal {
    }
    class person {
    }

    template&lt;class T&gt;
    void foo() {
      if (T is animal) {
        kill();
      }
    }
How do I do the check for T is animal? I don&#39;t want to have
something that checks during the run time. Thanks


How to check for the type of a template parameter?

I have a handlebars.js template, just like this:

    {{externalValue}}
    
    &lt;select name=&quot;test&quot;&gt;
        {{#each myCollection}}
           &lt;option value=&quot;{{id}}&quot;&gt;{{title}} {{externalValue}}&lt;/option&gt;
        {{/each}}
    &lt;/select&gt;

And this is the generated output:
    
    myExternalValue
    
    &lt;select name=&quot;test&quot;&gt;
           &lt;option value=&quot;1&quot;&gt;First element &lt;/option&gt;
           &lt;option value=&quot;2&quot;&gt;Second element &lt;/option&gt;
           &lt;option value=&quot;3&quot;&gt;Third element &lt;/option&gt;
    &lt;/select&gt;


As expected, I can access the `id` and `title` fields of every element of `myCollection` to generate my select. And outside the select, my `externalValue` variable is correctly printed (&quot;myExternalValue&quot;).

Unfortunately, in options&#39; texts, `externalValue` value is never printed out.

My question is: how can I access a variable outside the scope of the handlebars.js each from within the loop? 


Content Type	Original Author	Original Content on Stackoverflow
Question	RParadox	View Question on Stackoverflow
Solution 1 - Django	K Z	View Answer on Stackoverflow
Solution 2 - Django	pistache	View Answer on Stackoverflow
Solution 3 - Django	BigRetroMike	View Answer on Stackoverflow
Solution 4 - Django	Alvaro	View Answer on Stackoverflow

Django access the length of a list within a template

Django Problem Overview

Django Solutions

Solution 1 - Django

Solution 2 - Django

Solution 3 - Django

Solution 4 - Django

How to remove elements that were fetched using querySelectorAll?

Conversion hex string into ascii in bash command line

Attributions