Solving problem is about exposing yourself to as many situations as possible like Python for-in loop preceded by a variable and practice these strategies over and over. With time, it becomes second nature and a natural way you approach any problems in general. Big or small, always start with a plan, use other strategies mentioned here till you are confident and ready to code the solution.

In this post, my aim is to share an overview the topic about Python for-in loop preceded by a variable, which can be followed any time. Take easy to follow this discuss.

```
foo = [x for x in bar if x.occupants > 1]
```

After googling and searching on here, couldn’t figure out what this does. Maybe I wasn’t searching the right stuff but here it is. Any input in debunking this shorthand is greatly appreciated.

##
Answer #1:

The current answers are good, but do not talk about how they are just syntactic sugar to some pattern that we are so used to.

Let’s start with an example, say we have 10 numbers, and we want a subset of those that are greater than, say, 5.

```
>>> numbers = [12, 34, 1, 4, 4, 67, 37, 9, 0, 81]
```

For the above task, the below approaches below are totally identical to one another, and go from most verbose to concise, readable and ** pythonic**:

### Approach 1

```
result = []
for index in range(len(numbers)):
if numbers[index] > 5:
result.append(numbers[index])
print result #Prints [12, 34, 67, 37, 9, 81]
```

### Approach 2 (Slightly cleaner, for-in loops)

```
result = []
for number in numbers:
if number > 5:
result.append(number)
print result #Prints [12, 34, 67, 37, 9, 81]
```

### Approach 3 (Enter List Comprehension)

```
result = [number for number in numbers if number > 5]
```

### or more generally:

```
[function(number) for number in numbers if condition(number)]
```

where:

`function(x)`

takes an`x`

and transforms it into something useful (like for instance:`x*x`

)- if
`condition(x)`

returns any False-y value (False, None, empty string, empty list, etc ..) then the current iteration will be skipped (think`continue`

). If the function return a non-False-y value then the current value makes it to the final resultant array (and goes through the transformation step above).

To understand the syntax in a slightly different manner, look at the Bonus section below.

For further information, follow the tutorial all other answers have linked: List Comprehension

### Bonus

(Slightly un-pythonic, but putting it here for sake of completeness)

The example above can be written as:

```
result = filter(lambda x: x > 5, numbers)
```

The general expression above can be written as:

```
result = map(function, filter(condition, numbers)) #result is a list in Py2
```

##
Answer #2:

It’s a list comprehension

`foo`

will be a filtered list of `bar`

containing the objects with the attribute occupants > 1

`bar`

can be a `list`

, `set`

, `dict`

or any other iterable

Here is an example to clarify

```
>>> class Bar(object):
... def __init__(self, occupants):
... self.occupants = occupants
...
>>> bar=[Bar(0), Bar(1), Bar(2), Bar(3)]
>>> foo = [x for x in bar if x.occupants > 1]
>>> foo
[<__main__.Bar object at 0xb748516c>, <__main__.Bar object at 0xb748518c>]
```

So foo has 2 `Bar`

objects, but how do we check which ones they are? Lets add a `__repr__`

method to `Bar`

so it is more informative

```
>>> Bar.__repr__=lambda self:"Bar(occupants={0})".format(self.occupants)
>>> foo
[Bar(occupants=2), Bar(occupants=3)]
```

##
Answer #3:

The way this should work as far as I can tell is it checks to see if the list “bar” is empty (0) or consists of a singleton (1) via x.occupants where x is a defined item within the list bar and may have the characteristic of occupants. So foo gets called, moves through the list and then returns all items that pass the check condition which is x.occupant.

In a language like Java, you’d build a class called “x” where ‘x’ objects are then assigned to an array or similar. X would have a Field called “occupants” and each index would be checked with the x.occupants method which would return the number that is assigned to occupant. If that method returned greater than 1 (We assume an int here as a partial occupant would be odd.) the foo method (being called on the array or similar in question.) would then return an array or similar as defined in the foo method for this container array or what have you. The elements of the returned array would be the ‘x’ objects in the first array thingie that fit the criteria of “Greater than 1”.

Python has built-in methods via list comprehension to deal with this in a much more succinct and vastly simplified way. Rather than implementing two full classes and several methods, I write that one line of code.

##
Answer #4:

This return a list which contains all the elements in bar which have occupants > 1.

##
Answer #5:

Since the programming part of question is fully answered by others it is nice to know its relation to mathematics (set theory). Actually it is the Python implementation of Set builder notation:

Defining a set by axiom of specification:

B = { x ? A : S(x) }

English translation:

Bis a set where its members are chosen fromA,

soBis a subset ofA(B ? A), where characteristic(s) specified by

functionSholds:`S(x) == True`

Defining

Busing list comprehension:B = [x for x in A if S(x)]

So to build **B** with list comprehension, member(s) of **B** (denoted by **x**) are chosen from set **A** where `S(x) == True`

(inclusion condition).

Note: Function `S`

which returns a boolean is called predicate.