Let's manage our own supermarket and buy some goods along the way!


A Day at the Supermarket

Before we begin our exercise, we should go over the Python `for` loop one more time. For now, we are only going to go over the `for` loop in terms of how it relates to *lists* and *dictionaries*. We'll explain more cool `for` loop uses in later courses.

`for` loops allow us to iterate through all of the elements in a list from the left-most (or zeroth element) to the right-most element. A sample loop would be structured as follows: 

```py
a = ["List", "of", "some", "sort"]
for x in a: 
  # Do something for every x
```

This loop will run all of the code in the indented block under the `for x in a:` statement. The item in the list that is currently being evaluated will be `x`.  So running the following:

```py
for item in [1, 3, 21]: 
  print item
```

would print `1`, then `3`, and then `21`. The variable between `for` and `in` can be set to any variable name (currently `item`), but you should be careful to avoid using the word `list` as a variable, since that's a reserved word (that is, it means something special) in the Python language.

BeFOR We Begin

Now you need your `compute_bill` function to take the stock/inventory of a particular item into account when computing the cost.

Ultimately, if an item isn't in stock, then it shouldn't be included in the total. You can't buy or sell what you don't have!

Stocking Out 

For paperwork and accounting purposes, let's record the total value of your inventory. It's nice to know what we're worth!

Something of Value 

The blocks of code in a `for` loop can be as big or as small as they need to be.

While looping, you may want to perform different actions depending on the particular item in the list.

```py
numbers = [1, 3, 4, 7]
for number in numbers: 
  if number > 6:
    print number
print "We printed 7."
```

1. In the above example, we create a list with 4 numbers in it.
2. Then we loop through the `numbers` list and store each item in the list in the variable `number`.
3. On each loop, if `number` is greater than 6, we `print` it out. So, we print `7`.
4. Finally, we print out a sentence.

Make sure to keep track of your indentation or you may get confused!

Control Flow and Looping

Now that you have all of your product info, you should print out all of your inventory information.

```py
once  = {'a': 1, 'b': 2}
twice = {'a': 2, 'b': 4}
for key in once:
  print "Once: %s" % once[key]
  print "Twice: %s" % twice[key]
```

1. In the above example, we create two dictionaries, `once` and `twice`, that have the same keys.
2. Because we know that they have the same keys, we can loop through one dictionary and `print` values from both `once` and `twice`.

Keeping Track of the Produce 

Good! Now you're going to need to know how much you’re paying for all of the items on your grocery list.

```py
def sum(numbers):
  total = 0
  for number in numbers:
    total += number
  return total

n = [1, 2, 5, 10, 13]
print sum(n)
```

1. In the above example, we first define a function called `sum` with a parameter `numbers`.
2. We initialize the variable `total` which we will use as our running sum.
3. For each number in the list, we add that number to the running sum `total`.
4. At the end of the function, we return the running sum.
5. After the function, we create, `n`, a list of numbers.
6. Finally, we call the `sum(numbers)` function with the variable `n` and print the result.

Making a Purchase

Good work! As a store manager, you’re also in charge of keeping track of your stock/inventory.

Investing in Stock 

Functions can also take *lists* as inputs and perform various operations on those lists.

```py
def count_small(numbers):
  total = 0
  for n in numbers:
    if n < 10:
      total = total + 1
  return total

lotto = [4, 8, 15, 16, 23, 42]
small = count_small(lotto)
print small
```

1. In the above example, we define a function `count_small` that has one parameter, `numbers`.
2. We initialize a variable `total` that we can use in the `for` loop.
3. For each item `n` in `numbers`, if `n` is less than 10, we increment `total`.
4. After the `for` loop, we return `total`.
5. After the function definition, we create an array of numbers called `lotto`.
6. We call the `count_small` function, pass in `lotto`, and store the returned result in `small`.
7. Finally, we print out the returned result, which is `2` since only `4` and `8` are less than 10.

Lists + Functions

Okay—on to the core of our project.

Congratulations! You are now the proud owner of your very own Codecademy brand supermarket.

```py
animal_counts = {
  "ant": 3,
  "bear": 6,
  "crow": 2
}
```

In the example above, we create a new dictionary called `animal_counts` with three entries. One of the entries has the key `"ant"` and the value `3`.

Your Own Store!

Great work! Now we're going to take a step back from the management side and take a look through the eyes of the shopper. 

In order for customers to order online, we are going to have to make a consumer interface. Don't worry: it's easier than it sounds!

Shopping at the Market

As we've mentioned, *strings* are like lists with *characters* as elements. You can loop through strings the same way you loop through lists! While we won't ask you to do that in this section, we've put an example in the editor of how looping through a string might work.

String Looping

You can also use a `for` loop on a dictionary to loop through its *keys* with the following:

```py
# A simple dictionary
d = {"foo" : "bar"}

for key in d: 
  print d[key]  # prints "bar" 
```

Note that dictionaries are *unordered*, meaning that any time you loop through a dictionary, you will go through *every* key, but you are not guaranteed to get them in any particular order.

This is KEY!

Perfect! You've done a great job with *lists* and *dictionaries* in this project. You've practiced:

* Using `for` loops with lists and dictionaries
* Writing functions with loops, lists, and dictionaries
* Updating data in response to changes in the environment (for instance, decreasing the number of bananas in `stock` by 1 when you sell one).

Thanks for shopping at the Codecademy supermarket!