# Python For Django Programmers – Part 2

Jun 14

In this second tutorial on introductory Python for Django programmers, I will be covering math and string handling in Python, lists, dictionaries and tuples, branching with the `if` statement and looping with `while` and `for`.

This tutorial is an extract from my new book – Build Your First Website with Python and Django.

## Math and Numbers

Python has a simple and straight forward approach to programming math and numbers – if you are ok with high school math, you will be ok with Python math. Carrying on from earlier examples, here are a few more using the Python interactive interpreter:

``````>>> 50 - 5*6        # Mathematical precedence
20                  # PEMDAS, BEDMAS or BODMAS
>>> (50 - 5) * 6    # depending which country you're from
270
>>> 2**10           # Power functions
1024
>>> import math     # Python math module
>>> r = 10
>>> area = math.pi*(r**2)       # Using pi
>>> math.pi*(r**2)
314.1592653589793
>>> math.cos(math.radians(60))  # Trigonometry
0.5000000000000001
>>> math.log(256,2)             # logarithms
8.0
>>> import random               # Python random module
>>> random.random()
0.5362880665009504
>>> random.randrange(12)
11
>>> random.randrange(12)
4
>>>``````

There are dozens more functions you can use to do math and manipulate numbers in Python. For a list of all math functions, check out the Python documentation.

## Strings

A string is simply a sequence of one or more characters – “a” is a string, “Hello There” is a string, if you were silly enough to load it all into a single variable, this whole book could be a string. String characters don’t have to be printable – a string can contain any Unicode character.

Strings are immutable. An immutable object cannot be changed after it’s created. I will be talking more about immutable and mutable objects shortly when I cover lists, tuples and dictionaries.

To create a string, you simply enclose the string in single or double quotes:

``````x = 'Hello'
y = "There"``````

The only time it matters if you use single or double quotes is if there are quotes in the string:

``````a = 'This doesn't work'# BAD, will break on quote in "doesn't"
b = "Wasn't that easy" # GOOD
c = '"Air quotes" are silly' # Also GOOD``````

If there are multiple quotes in the string, you have to escape the quotes with a backslash (`\`):

``d = "Aren't quotes \"fun\"?"``

Strings are a special class built in to Python, with a large number of class methods available for working with them. Here are a few examples using the Python interactive interpreter:

``````>>> "hello".capitalize()        # Manipulate a string directly
# Capitalize string
'Hello'
>>> "hello".upper()             # Uppercase string
'HELLO'
>>> greet = "Hello There"       # Work with string variable
>>> greet                    # String indexing
'H'                             # First character
>>> greet
'T'                             # Seventh character
>>> greet[:4]                   # String slicing
'Hell'                          # First four characters
>>> greet[len(greet)-4:]
'here'                          # Last four characters
>>> greet[::-1]                 # Reverse a string
'erehT olleH'
>>> strPadded = "     My name is Nige   "
'My name is Nige   '            # Removing whitespace
'     My name is Nige'
>>> greet.replace("e","_")      # Replacing characters in a string
'H_llo Th_r_'
>>> greet.split()               # Splitting strings
['Hello', 'There']              # Default split is space
>>> greet.split("e")            # But can split on anything
['H', 'llo Th', 'r', '']
>>>``````

Like math and numbers, this is only a small taste of what can be achieved with the string class. For more information see the Python string class documentation.

### Formatting Strings

Another really useful thing you can do with strings is to use string interpolation to substitute values into a formatted string. This is easier explained with an example. Try this at the Python prompt:

``>>> "There are %s apples left" % "four"``

String interpolation is performed with the modulo (`%`) operator and takes the form:

``format % values``

So when you enter the above code, Python replaces the string placeholder (`%s`) with the string “four”. When you hit enter, Python prints out:

``````'There are four apples left'
>>>``````

This works on multiple substitutions, however with multiple substitutions the values must be passed in as a tuple (more on tuples shortly):

``````>>> "There are %s apples and %s oranges left" % ("four","two")
'There are four apples and two oranges left'``````

String formatting doesn’t just work with substituting string variables – `%i` will insert an integer:

``````>>> "There are %i apples and %i oranges left" % (2,7)
'There are 2 apples and 7 oranges left'
>>>``````

Other format strings include:

• `%X` – A signed hexadecimal (uppercase)
• `%f` – A floating point decimal
• `%c` – A single character

For more on formatting strings, see the Python documentation on String Formatting Operations.

## Lists, Dictionaries and Tuples

Lists, dictionaries and tuples are used to store collections of objects. They are differentiated from each other by the delimiter they use:

• `[]` – a list. E.g. `["one","two"]`
• `{}` – a dictionary. E.g. `{1:"one", 2:"two"}`
• `()` – a tuple. E.g. `("one", 2)`

Lists you should be very familiar with, as we all use lists daily. A dictionary is also pretty straight forward – think of a regular dictionary where you have the word and then the meaning of the word. In Python, the word is called a `key` and the definition a `value`.

Tuples are like lists, with a couple of differences. Lists are designed to contain largely homogeneous data, much like in real life where you would have a shopping list or a to do list. By convention, Python list items should all be the same type (although Python doesn’t enforce this rule).

Tuples, on the other hand, are used to store heterogeneous data – `("one", 2, [three])` is perfectly acceptable as a tuple, where it would be frowned upon as a list. A single element tuple (singleton) is also written differently to a single element list:

``````lst = ["one"]   # Single element list
tpl = ("one",)  # Single element tuple must have trailing comma
# to differentiate between a plain string ("one")
# or a functions parameter some_func("one")``````

Tuples, like strings, are immutable. Once they are created, you can’t change them. Lists and dictionaries, however, are mutable and can be changed. Let me illustrate with some examples:

``````>>> lst = ["one"]           # Set up a list, tuple and dictionary
>>> tpl = ("one",)
>>> dict = {0:"one"}
>>> lst                  # All contain the same first element
'one'
>>> tpl
'one'
>>> dict
'one'
>>> lst = "two"          # List is mutable (can be changed)
>>> lst
['two']
>>> dict = "two"         # So is the dictionary
>>> dict
{0: 'two'}
>>> tpl = "two"          # Tuple is immutable. Can't change it!
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment

>>> str = "one"             # String is also immutable
>>> str = "x"
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: 'str' object does not support item assignment``````

One last point on tuples vs. lists – tuples are often used for homogeneous data that the programmer doesn’t want changed by accident. So if you have a list of items that should not be changed, it’s can be a good idea to use a tuple instead of a list.

And a final note – if you want to see a number of examples on how lists and dictionaries are used in Django, check out your project’s `settings.py` file.

## The `if` Statement and Code Branching

Python, like most programming languages, has an `if` statement that provides branching in your code. The syntax of Python’s `if` statement is as follows:

``````if [expression is True]:
# execute this code when True
else:
# execute this code when False``````

The `else` branch is optional:

``````if [expression is True]:
# only executes when True

# resume code execution``````

The expression can be anything that evaluates to `True` or `False`. A few examples:

1. `if num >= 10:`
2. `if str == "Hello:`
3. `if this != that:`
4. `if SomeVar:`

… and so on.

Take note of example 4 above – in Python, anything that does not equate to zero, `Null`, or an empty object is `True`. So this works:

``````>>> s = 0
>>> if s:
...     print('T')
...
>>> s = 1
>>> if s:
...     print('T')
...
T
>>> s = ""
>>> if s:
...     print('T')
...
>>> s = "Hello"
>>> if s:
...     print('T')
...
T
>>>``````

Python includes a comprehensive range of boolean operators that you can use within your expressions:

• `<`– Less than
• `<=` – Less than or equal
• `>`– Greater than
• `>=` – Greater than or equal
• `==` – Equal
• `!=` – Not equal
• `is` – Is a particular object
• `is not` – Isn’t a particular object

Boolean operations are also supported for negating and chaining expressions:

• `or`– Either expression can be `True`
• `and` – Both expressions must be `True`
• `not` – Negate the proceeding expression

Python also supports multiple branching using the `elif` (else if) statement:

``````if [exp1 is True]:
# execute if exp1 is True
elif [exp2 is True]:
# execute if exp2 is True
elif [exp3 is True]:
# execute if exp3 is True
# and so on ...
else:
# execute this code when all else fails``````

## Loops and Iterators

Loops and iterators both do the same basic thing – repeat a section of code until some condition is met. With a loop, the repetition can be any arbitrary code sequence, whereas an iterator steps through an iterable object. An iterable object is an object that can be indexed (stepped through) in a sequential way. The most common iterable types in Python are the sequence types – strings, lists, tuples and ranges.

### The `while` Loop

To create a program loop in Python, you use the `while` statement. For example, here is a very simple loop:

``````a = 1
while a < 5:
print(a)
a+=1``````

This should be easy to follow:

1. Set the value of `a` to 1.
2. Start a loop with the `while` statement
3. Print out the current value of `a`
4. Increment `a`
5. Repeat while the expression `a < 5` is True.

If you run this code at the Python prompt, your output should look like this:

``````>>> while a < 5:
...     print(a)
...     a+=1
...
1
2
3
4
>>>``````

Python’s `while` loops are very useful and can be used for much more than simple tasks like printing out a variable. For example, the factorial (`!`) of any number is simply the multiplication of the number and all the preceding integers (so 4! is equal to 1*2*3*4). Here’s how to calculate the factorial of 9 with a `while` loop:

``````fact, mul = 1, 2    # Multiple assignment
while mul < 10:
fact, mul = fact*mul, mul + 1
print(fact)``````

In the first line I am using multiple assignment, which is a useful feature of Python’s programming syntax. The statement `fact, mul = 1, 2` is a shorthand way of writing:

``````fact = 1
mul = 2``````

Line 3 is where all the magic happens, first we multiply the current value of `fact` by `mul` and then we increment `mul` by 1. We then print out the new value of `fact`. If you run this at they Python prompt, you should see something like this:

``````>>> fact, mul = 1, 2
>>> while mul < 10:
...     fact, mul = fact*mul, mul + 1
...     print(fact)
...
2
6
24
120
720
5040
40320
362880
>>>``````

### Breaking out of Loops

The `break` and `continue` statements allow you to exit a loop before the loop condition is met. Consider the following code:

``````a, b = 1, 1
while a < 5:
print("a =", a)
a +=1
while b < 5:
print("b = ", b)
if b == 2:
b = 1
break
b +=1``````

The `break` statement will only exit the currently running loop, so in the above example the `break` statement only exits the inner `while` loop. Let’s see what the output is when we run this code:

``````>>> while a < 5:
...     print("a =", a)
...     a +=1
...     while b < 5:
...         print("b = ", b)
...         if b == 2:
...             b = 1
...             break
...         b +=1
...
a = 1
b =  1
b =  2
a = 2
b =  1
b =  2
a = 3
b =  1
b =  2
a = 4
b =  1
b =  2
>>>``````

You can see that the `break` statement doesn’t affect the outer loop – it continues to run until `a < 5` is False. Because the inner loop always breaks when `b` is equal to 2, the inner `while` loop never completes.

The `continue` statement, on the other hand, won’t execute any of the code after the `continue` statement, but instead it jumps to the next iteration of the loop. Consider the following code:

``````a = 0
while a < 5:
a+=1
if a == 3:
print("My favorite number is", a)
continue    # Go to next iteration of loop
print("a =", a)  # The continue statement will stop
# this from printing when a equals 3``````

Run this code and you should see the different string printed when `a` equals 3:

``````>>> a = 0
>>> while a < 5:
...     a+=1
...     if a == 3:
...         print("My favorite number is", a)
...         continue
...     print("a =", a)
...
a = 1
a = 2
My favorite number is 3
a = 4
a = 5
>>>``````

The `break` and `continue` statements can also be used inside a `for` loop.

### Iterating with a `for` Loop

The `for` loop is designed to step through an iterable item. It takes the basic form:

``for [item] in [iterable]:``

As I said earlier in the chapter, the most common iterables are strings, lists, tuples and ranges. Here are some examples:

``````>>> word = "Hello"
>>> for char in word:   # Step through each character in the word
...     print(char)
...
H
e
l
l
o
>>> lst = ['1','2','3'] # Step through each item in the list
>>> for item in lst:
...     print(item)
...
1
2
3
>>> tup = (1,"two", 3)  # Step through each item in the tuple
>>> for item in tup:
...     print(item)
...
1
two
3
>>> for i in range(5):  # The range function provides you
...     print(i)        # with a sequence of integers
...
0
1
2
3
4
>>>``````

This should all be easy to follow. The `range()` function we haven’t covered, but it’s basically an easy way of creating a sequence of numbers. More on the `range()` function in the Python documentation.

This post is an extract from my new book – Build Your First Website with Python and Django.