Here’s a code sample with a for loop:

l1 = [0, 1, 2, 3, 4, 5]
l2 = []
for i in l1:
    l2.append(i*2)

A simple for loop that takes a list and adds the double of each element to another list.
This is a fairly common construction in beginner Python code, loop over a list and perform actions on each element.
Now we’ll write the same functionality using a list comprehension:
l = [0, 1, 2, 3, 4, 5]
l = [i*2 for i in l]

This code is fairly simple even though it seems strange. Our list comprehension on line #2 contains roughly the same format as a for loop. The part for i in l obviously loops over all elements of our list. The part in front of the for-loop like part i*2 simply tells the list comprehension what to do with the current element.
You can read this list comprehension as:
return i*2 for i in l
The return part of our list comprehension is fairly limited. Should you want to do more advanced things you should define a function first and use that in the return part of your list comprehension:

def complex_function(val):
    # complex calculation
    # be sure to return a value
    return val
l = [0, 1, 2, 3, 4, 5]
l = [complex_function(i) for i in l]

In our list comprehensions, we’ve seen two ‘parts’ of our list comprehension. The return part that gets the current element, performs an action and returns it in a new list. The second part is the loop part of the list, this part tells our list comprehension what list to iterate.

Now we’ll add a third part, which I call the filter part:

l = [0, 1, 2, 3, 4, 5, 6, 7, 8]
l = [i*2 for i in l if i % 2 == 0]
After the loop part we’ve added the header of an if statement. If this part is True for the current element, the return part of our list comprehension will be executed.

There’s lots more you can do with list comprehensions like multiple lists or nest list comprehensions.

The official Python documentation about list comprehensions is here: http://docs.python.org/2/tutorial/datastructures.html#list-comprehensions

For future reference, this post was writting using Django 1.4

A simple validator can be a Python function that takes a value, checks this value against your logic and raises a ValidationError if the value fails to a agree to your rules.

In our example below, we’ll write a validator that checks if a given value is greater than or equal to 30.

from django.core.exceptions import ValidationError
def validate_product_price(val):
    if val >= 30:
        raise ValidationError(u”Not a valid product price”)

After importing the required exception from the Django module we define our function which takes one parameter, val. Our function simple does some checks on this value and raises the ValidationError exception with some extra information.
Now that we have our validator function defined we can assign it to our model:

class Product(models.Model):
    product_code = models.CharField(max_length=5, unique=True)
    name = models.CharField(max_length=30)
    price = models.FloatField(validators=[validate_product_price])
    # Rest of our model definition…

When using this model in a form (Form or ModelForm) the calling of the fields clean() method will result in your custom validator being called.
In a later post I’ll detail the validation flow of Django forms, models and fields. We will also see how you can validate a field depending other field values.

Django has a number of built-in validators that can be used in your code. They take care of various general validation requirements such as email, IP address, length or value validation. You can check out the official Django documentation about validators here: https://docs.djangoproject.com/en/1.4/ref/validators/

The configuration below tells Nginx to listen for HTTP traffic on port 80 that was sent to www.project.com, all requests received are then distributed over the upstream servers that are defined:

http {
  upstream myservers {
    server 192.168.0.2:8000;
    server 192.168.0.3:8000;
    server 192.168.0.4:8000;    
    server 192.168.0.5:8000;
  }

  server {
    listen 80;
    server_name www.project.com;
    location / {
      proxy_pass http://myservers;
    }
  }
}

The setup above will treat all backend servers equally. Using the weight option it is possible to direct more traffic to a server, for example when it’s on a more powerful machine:

server 192.168.0.2:8000 weight=4;

You can check out everything about Nginx configuration on the Wiki.

Like always, let’s start with an ‘bad’ example:

l = ['car', 'bike', 'boat', 'plane']
j = 1
for transport in l:
print j, transport
j += 1

This trivial example iterates over a list and we keep track of the element using a counter. We then print out every element along with the counter.
Now our example using the enumerate() function:

l = ['car', 'bike', 'boat', 'plane']
for j, transport in enumerate(l):
print j+1, transport

As we can see the enumerate function offers us the element and the index of the element (that’s why we use j+1, 0 based indexes!).
When we look at the enumerate function we see that it returns an enumerate object. This enumerate object contains an iterator that gives us a list of tuples:

>>> l = ['car', 'bike', 'boat', 'plane']
>>> list(enumerate(l))
[(0, 'car'), (1, 'bike'), (2, 'boat'), (3, 'plane')]

So in our for loop we go over all tuples and unpack them into j, transport.
Extra tip: pass along an extra parameter to the enumerate function to define the start the indexing:

>>> l = ['car', 'bike', 'boat', 'plane']
>>> list(enumerate(l, 1))
[(1, 'car'), (2, 'bike'), (3, 'boat'), (4, 'plane')]

Deze module is geïntegreerd met onze modules:

Deze module is geïntegreerd met onze modules: