# Trick Sheet¶

This page contains concise ways to manipulate data in Python that can save you time and code.

## Clamp Function¶

A clamp function (`clamp(x, minimum, maximum)`) lets you constrain the value of an input to a range. If I want to clamp a value x between 1 and 5, the outputs of clamp(x, 1, 5) would look like:

x clamp(x, 1, 5)
0 1
1 1
4 4
8 5

Writing this kind of function will be helpful in all kinds of places in 6.101. A straightforward way we could write this is by checking whether the value is below the min or above the max and returning the appropriate boundary.

``````def clamp(x, minimum, maximum):
"""
Returns x if minimum < x < maximum. Otherwise, returns the appropriate
boundary.
"""
if x < minimum:
return minimum
if x > maximum:
return maximum
return x
``````

However, notice that the built-in min and max functions achieve a one-sided clamp, half the work of our two-sided clamp above.

``````def clamp_left(x, minimum):
"""
Returns x if x > minimum. Otherwise, returns minimum.
"""
return max(x, minimum)

def clamp_right(x, maximum):
"""
Returns x if x < maximum. Otherwise, returns maximum.
"""
return min(x, maximum)
``````

It turns out we can combine `min` and `max` together to make an elegant clamp function by just nesting one inside the other! I like to structure the clamp with the `max` function on the outside and the minimum value on the left, so that the clamp looks like the statement `minimum < x < maximum`.

``````def clamp(x, minimum, maximum):
"""
Returns x if minimum < x < maximum. Otherwise, returns the appropriate
boundary.
"""
return max(minimum, min(x, maximum))
``````

You don't need to write this as a function if you don't want to! Say we have a list `data` of variable length. Now, we have a nice way to make sure whatever index we provide can access a valid data point.

``````def access_data(index):
"""Returns the nearest data point to index."""
return data[max(0, min(index, len(data)))]
``````

### Range Check¶

Sometimes we just want to check if a value is in a range instead of clamping it. A simple way to do this in Python is with a comparison. Operators like `<` and `==` wil let you string together three values in a single comparison.

If we want to check whether x is within 1 and 5, we can use `1 <= x <= 5`, like so:

``````>>> x = 10
>>> 1 <= x <= 5
False
>>> x = 3
>>> 1 <= x <= 5
True
``````

## Infinity¶

Python has a way to represent infinity, which might be helpful to you to specify values that are invalid or out-of-bounds when looping through a data structure. To use this value, use `float('inf')`.

``````>>> # Using infinity for players with invalid scores
>>> scores = [15, float('inf'), 20, 3, float('inf'), 30]
>>> min(scores)
3
``````