In this lesson, we'll cover some of the more complex aspects of Python, including iterating over data structures, list comprehensions, list slicing, and lambda expressions.

Advanced Topics in Python

All right! Time to test out `filter()` and `lambda` expressions.

```py
cubes = [x ** 3 for x in range(1, 11)]
filter(lambda x: x % 3 == 0, cubes)
```

The example above is just a reminder of the syntax.

Try It!

One of the more powerful aspects of Python is that it allows for a style of programming called **functional programming**, which means that you're allowed to pass functions around just as if they were variables or values. Sometimes we take this for granted, but not all languages allow this!

Check out the code at the right. See the `lambda` bit? Typing
```py
lambda x: x % 3 == 0
```
Is the same as
```py
def by_three(x):
  return x % 3 == 0
```
Only we don't need to actually give the function a name; it does its work and returns a value without one. That's why the function the lambda creates is an *anonymous function*.

When we pass the lambda to `filter`, `filter` uses the lambda to determine what to filter, and the second argument (`my_list`, which is just the numbers 0 – 15) is the list it does the filtering on.

Anonymous Functions

A positive stride length traverses the list from left to right, and a negative one traverses the list from right to left.

Further, a stride length of 1 traverses the list "by ones," a stride length of 2 traverses the list "by twos," and so on.

Stride Length

Great work! See? This list slicing business is pretty straightforward.

Let's do one more, just to prove you really know your stuff.

Practice Makes Perfect

While `.items()` returns an array of *tuples* with each tuple consisting of a key/value pair from the dictionary:

* The `.keys()` method returns a list of the dictionary's keys, and
* The `.values()` method returns a list of the dictionary's values.

Again, these methods will not return the keys or values from the dictionary in any specific order.

You can think of a tuple as an immutable (that is, unchangeable) list. Tuples are surrounded by `()`s and can contain any data type.

keys() and values()

For iterating over lists, tuples, dictionaries, and strings, Python also includes a special keyword: `in`. You can use `in` very `in`tuitively, like so:

```py
for number in range(5):
  print number,

d = { 
  "name": "Eric",
  "age": 26
}

for key in d:
  print key, d[key],

for letter in "Eric":
  print letter,  # note the comma!
```

1. In the example above, first we create and iterate through a range, printing out `0 1 2 3 4`. Note that the trailing comma ensures that we keep printing on the same line.
2. Next, we create a dictionary and iterate through, printing out `age 26 name Eric`. Dictionaries have no specific order.
3. Finally, we iterate through the letters of a string, printing out `E r i c`.



The 'in' Operator

Lambda functions are defined using the following syntax:

```py
my_list = range(16)
filter(lambda x: x % 3 == 0, my_list)
```

Lambdas are useful when you need a quick function to do some work for you.

If you plan on creating a function you'll use over and over, you're better off using `def` and giving that function a name.

Lambda Syntax

Good! Now let's take another look at list comprehensions.

```py
squares = [x ** 2 for x in range(5)]
```

Comprehending Comprehensions

We have seen that a positive stride progresses through the list from left to right.

A *negative* stride progresses through the list from right to left.

```py
letters = ['A', 'B', 'C', 'D', 'E']
print letters[::-1]
```

In the example above, we print out `['E', 'D', 'C', 'B', 'A']`.

Reversing a List

Great work! Now it's time for you to create a list comprehension all on your own.

```py
c = ['C' for x in range(5) if x < 3]
print c
```

The example above creates and prints out a list containing `['C', 'C', 'C']`.

Now You Try!

Let's say you wanted to build a list of the numbers from 0 to 50 (inclusive). We could do this pretty easily:

```py
my_list = range(51)
```

But what if we wanted to generate a list according to some logic—for example, a list of all the even numbers from 0 to 50?

Python's answer to this is the **list comprehension**. List comprehensions are a powerful way to generate lists using the `for`/`in` and `if` keywords we've learned.

Building Lists

Great! Next up: list slicing.

```py
str = "ABCDEFGHIJ"
start, end, stride = 1, 6, 2
str[start:end:stride]
```

You can think of a Python string as a list of characters.

List Slicing

Here's a simple example of list comprehension syntax:

```py
new_list = [x for x in range(1, 6)]
# => [1, 2, 3, 4, 5]
```

This will create a `new_list` populated by the numbers one to five. If you want those numbers doubled, you could use:

```py
doubles = [x * 2 for x in range(1, 6)]
# => [2, 4, 6, 8, 10]
```

And if you only wanted the doubled numbers that are evenly divisible by three:

```py
doubles_by_3 = [x * 2 for x in range(1, 6) if (x * 2) % 3 == 0]
# => [6]
```

List Comprehension Syntax

Let's start with iterating over a dictionary. Recall that a dictionary is just a collection of keys and values.

```py
d = {
  "Name": "Guido",
  "Age": 56,
  "BDFL": True
}
print d.items()
# => [('BDFL', True), ('Age', 56), ('Name', 'Guido')]
```

Note that the `.items()` method doesn't return key/value pairs in any specific order.

Iterators for Dictionaries

First, let's review iterating over a `dict`.

Iterating Over Dictionaries

Sometimes we only want part of a Python list. Maybe we only want the first few elements; maybe we only want the last few. Maybe we want every other element!

List slicing allows us to access elements of a list in a concise manner. The syntax looks like this:

```py
[start:end:stride]
```

Where `start` describes where the slice starts (inclusive), `end` is where it ends (exclusive), and `stride` describes the space between items in the sliced list. For example, a stride of `2` would select every other item from the original list to place in the sliced list.

List Slicing Syntax

Last but not least, let's look over some `lambda`s.

```py
my_list = range(16)
filter(lambda x: x % 3 == 0, my_list)
```

We've given you another (slightly different) `garbled`. Sort it out with a `filter()` and a `lambda`.

Lambda Expressions

If you don't pass a particular index to the list slice, Python will pick a default. 

```py
to_five = ['A', 'B', 'C', 'D', 'E']

print to_five[3:]
# prints ['D', 'E'] 

print to_five[:2]
# prints ['A', 'B']

print to_five[::2]
# print ['A', 'C', 'E']
```

1. The default starting index is `0`.
2. The default ending index is the end of the list.
3. The default stride is `1`.