Loops allow you to quickly iterate over information in Python. In this lesson, we'll cover two types of loop: 'while' and 'for'.

Loops

This kind of loop is useful when you want to do something a certain number of times, such as append something to the end of a list.

For your hobbies

Perhaps the most useful (and most common) use of `for` loops is to go through a list.

On each iteration, the variable `num` will be the next value in the list.  So, the first time through, it will be `7`, the second time it will be `9`, then `12`, `54`, `99`, and then the loop will exit when there are no more values in the list.

For your lists

An alternative way to loop is the `for` loop.  The syntax is as shown in the code editor. This example means "for each number `i` in the range 0 - 9,  print `i`".

For your health

As mentioned, the `else` block won't run in this case, since `break` executes when it hits `'tomato'`.

Change it up

A weakness of using this for-each style of iteration is that you don't know the index of the thing you're looking at.  Generally this isn't an issue, but at times it is useful to know how far into the list you are.  Thankfully the built-in `enumerate` function helps with this.

`enumerate` works by supplying a corresponding index to each element in the list that you pass it.  Each time you go through the loop, `index` will be one greater, and `item` will be the next item in the sequence.  It's very similar to using a normal `for` loop with a list, except this gives us an easy way to count how many items we've seen so far.

Counting as you go

The *condition* is the expression that decides whether the loop is going to continue being executed or not.  There are 5 steps to this program:

1. The `loop_condition` variable is set to `True`

2. The `while` loop checks to see if `loop_condition` is `True`.  It is, so the loop is entered.

3. The `print` statement is executed.

4. The variable `loop_condition` is set to `False`.

5. The `while` loop again checks to see if `loop_condition` is `True`.  It is not, so the loop is not executed a second time.

Condition

A common application of a `while` loop is to check user input to see if it is valid.  For example, if you ask the user to enter `y` or `n` and they instead enter `7`, then you should re-prompt them for input.

Simple errors

An *infinite loop* is a loop that never exits.  This can happen for a few reasons:

1. The loop condition cannot possibly be false (*e.g.* `while 1 != 2`)

2. The logic of the loop prevents the loop condition from becoming false.

Example:

```py
count = 10
while count > 0:
  count += 1 # Instead of count -= 1
```

Infinite loops

Using a `for` loop, you can print out each individual character in a string.  

The example in the editor is almost plain English: "for each character `c` in `thing`, print `c`".

For your strings

Inside a `while` loop, you can do anything you could do elsewhere, including arithmetic operations.


While you're at it

Just like with `while`, `for` loops may have an `else` associated with them.

In this case, the `else` statement is executed after the `for`, but only if the `for` ends normally—that is, not with a `break`. This code will `break` when it hits `'tomato'`, so the `else` block won't be executed.

For / else

You may be wondering how looping over a dictionary would work. Would you get the key or the value?

The short answer is: you get the key which you can use to get the value.

```py
d = {'x': 9, 'y': 10, 'z': 20}
for key in d:
  if d[key] == 10:
    print "This dictionary has the value 10!"
```

1. First, we create a dictionary with strings as the keys and numbers as the values.
2. Then, we iterate through the dictionary, each time storing the key in `key`.
3. Next, we check if that key's value is equal to 10. 
4. If so, we print `"This dictionary has the value 10!"`

Looping over a dictionary

The `break` is a one-line statement that means "exit the current loop."  An alternate way to make our counting loop exit and stop executing is with the `break` statement.  

* First, create a `while` with a condition that is always true. The simplest way is shown.

* Using an `if` statement, you define the *stopping condition*.  Inside the `if`, you write `break`, meaning "exit the loop."

The difference here is that this loop is guaranteed to run at least once.

Break

To wrap up this lesson, let's create our own `for`/`else` statement from scratch.

Create your own

Now you should be able to make a game similar to the one in the last exercise. The code from the last exercise is below:

```py
count = 0
while count < 3:
  num = random.randint(1, 6)
  print num
  if num == 5:
    print "Sorry, you lose!"
    break
  count += 1
else:
  print "You win!"
```

In this exercise, allow the user to guess what the number is `3` times. 

```py
guess = int(raw_input("Your guess: "))
```

Remember, `raw_input` turns user input into a string, so we use `int()` to make it a number again.

Your own while / else

The `while` loop is similar to an `if` statement: it executes the code inside of it if some condition is true.  The difference is that the `while` loop will continue to execute as long as the condition is true.  In other words, instead of executing if something is true, it executes while that thing is true.

Line 6 decides when the loop will be executed. So, "as long as `count` is less than `5`," the loop will continue to execute. Line 8 increases `count` by 1.  This happens over and over until `count` equals `5`.

While you're here

String manipulation is useful in `for` loops if you want to modify some content in a string. 

```py
word = "Marble"
for char in word:
  print char,
```

The example above iterates through each character in `word` and, in the end, prints out `M a r b l e`.

The `,` character after our `print` statement means that our next `print` statement keeps printing on the same line.

For your A

Something completely different about Python is the `while`/`else` construction. `while`/`else` is similar to `if`/`else`, but there is a difference: the `else` block will execute **anytime** the loop condition is evaluated to `False`.  This means that it will execute if the loop is never entered or if the loop exits normally.  If the loop exits as the result of a `break`, the `else` will not be executed.

In this example, the loop will `break` if a 5 is generated, and the `else` will not execute.  Otherwise, after 3 numbers are generated, the loop condition will become false and the else will execute.

While / else

It's also common to need to iterate over two lists at once.  This is where the built-in `zip` function comes in handy.

`zip` will create pairs of elements when passed two lists, and will stop at the end of the shorter list.

`zip` can handle three or more lists as well!