In computing, an idempotent operation is one that has no additional effect if it is called more than once with the same input parameters. For example, removing an item from a set can be considered an idempotent operation on the set.

In mathematics, an idempotent operation is one where *f(f(x)) = f(x)*. For example, the `abs()`

function is idempotent because `abs(abs(x)) = abs(x)`

for all `x`

.

These slightly different definitions can be reconciled by considering that *x* in the mathematical definition represents the state of an object, and *f* is an operation that may mutate that object. For example, consider the Python `set`

and its `discard`

method. The `discard`

method removes an element from a set, and does nothing if the element does not exist. So:

```
my_set.discard(x)
```

has exactly the same effect as doing the same operation twice:

```
my_set.discard(x)
my_set.discard(x)
```

Idempotent operations are often used in the design of network protocols, where a request to perform an operation is guaranteed to happen at least once, but might also happen more than once. If the operation is idempotent, then there is no harm in performing the operation two or more times.

See the Wikipedia article on idempotence for more information.

^{The above answer previously had some incorrect and misleading examples. Comments below written before April 2014 refer to an older revision.}