# Index all *except* one item in python

Each Answer to this Q is separated by one/two green lines.

Is there a simple way to index all elements of a list (or array, or whatever) except for a particular index? E.g.,

• `mylist` will return the item in position 3

• `milist[~3]` will return the whole list except for 3

For a list, you could use a list comp. For example, to make `b` a copy of `a` without the 3rd element:

``````a = range(10)[::-1]                       # [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
b = [x for i,x in enumerate(a) if i!=3]   # [9, 8, 7, 5, 4, 3, 2, 1, 0]
``````

This is very general, and can be used with all iterables, including numpy arrays. If you replace `[]` with `()`, `b` will be an iterator instead of a list.

Or you could do this in-place with `pop`:

``````a = range(10)[::-1]     # a = [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
a.pop(3)                # a = [9, 8, 7, 5, 4, 3, 2, 1, 0]
``````

In numpy you could do this with a boolean indexing:

``````a = np.arange(9, -1, -1)     # a = array([9, 8, 7, 6, 5, 4, 3, 2, 1, 0])
b = a[np.arange(len(a))!=3]  # b = array([9, 8, 7, 5, 4, 3, 2, 1, 0])
``````

which will, in general, be much faster than the list comprehension listed above.

The simplest way I found was:

``````mylist[:x] + mylist[x+1:]
``````

that will produce your `mylist` without the element at index `x`.

### Example

``````mylist = [0, 1, 2, 3, 4, 5]
x = 3
mylist[:x] + mylist[x+1:]
``````

Result produced

``````mylist = [0, 1, 2, 4, 5]
``````

``````>>> l = range(1,10)
>>> l
[1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> l[:2]
[1, 2]
>>> l[3:]
[4, 5, 6, 7, 8, 9]
>>> l[:2] + l[3:]
[1, 2, 4, 5, 6, 7, 8, 9]
>>>
``````

Explain Python’s slice notation

If you are using numpy, the closest, I can think of is using a mask

``````>>> import numpy as np
>>> arr = np.arange(1,10)
array([1, 2, 3, 4, 5, 7, 8, 9])
``````

Something similar can be achieved using `itertools` without `numpy`

``````>>> from itertools import compress
>>> arr = range(1,10)
[1, 2, 3, 4, 5, 7, 8, 9]
``````

Use `np.delete` ! It does not actually delete anything inplace

In your example, “mylist[~3]” would be written like that: `mylist.delete(3)`

A more complex example:

``````import numpy as np
a = np.array([[1,4],[5,7],[3,1]])

# a: array([[1, 4],
#           [5, 7],
#           [3, 1]])

ind = np.array([0,1])

# ind: array([0, 1])

# a[ind]: array([[1, 4],
#                [5, 7]])

all_except_index = np.delete(a, ind, axis=0)
# all_except_index: array([[3, 1]])

# a: (still the same): array([[1, 4],
#                             [5, 7],
#                             [3, 1]])
``````

I’m going to provide a functional (immutable) way of doing it.

1. The standard and easy way of doing it is to use slicing:

``````index_to_remove = 3
data = [*range(5)]
new_data = data[:index_to_remove] + data[index_to_remove + 1:]

print(f"data: {data}, new_data: {new_data}")
``````

Output:

``````data: [0, 1, 2, 3, 4], new_data: [0, 1, 2, 4]
``````
2. Use list comprehension:

``````data = [*range(5)]
new_data = [v for i, v in enumerate(data) if i != index_to_remove]

print(f"data: {data}, new_data: {new_data}")
``````

Output:

``````data: [0, 1, 2, 3, 4], new_data: [0, 1, 2, 4]
``````
3. Use filter function:

``````index_to_remove = 3
data = [*range(5)]
new_data = [*filter(lambda i: i != index_to_remove, data)]
``````

Output:

``````data: [0, 1, 2, 3, 4], new_data: [0, 1, 2, 4]
``````
4. Using masking. Masking is provided by itertools.compress function in the standard library:

``````from itertools import compress

index_to_remove = 3
data = [*range(5)]

``````

Output:

``````data: [0, 1, 2, 3, 4], mask: [1, 1, 1, 0, 1], new_data: [0, 1, 2, 4]
``````
5. Use itertools.filterfalse function from Python standard library

``````from itertools import filterfalse

index_to_remove = 3
data = [*range(5)]
new_data = [*filterfalse(lambda i: i == index_to_remove, data)]

print(f"data: {data}, new_data: {new_data}")
``````

Output:

``````data: [0, 1, 2, 3, 4], new_data: [0, 1, 2, 4]
``````

If you don’t know the index beforehand here is a function that will work

``````def reverse_index(l, index):
try:
l.pop(index)
return l
except IndexError:
return False
``````

Note that if variable is list of lists, some approaches would fail.
For example:

``````v1 = [[range(3)] for x in range(4)]
v2 = v1[:3]+v1[4:] # this fails
v2
``````

For the general case, use

``````removed_index = 1
v1 = [[range(3)] for x in range(4)]
v2 = [x for i,x in enumerate(v1) if x!=removed_index]
v2
``````

If you want to cut out the last or the first do this:

``````list = ["This", "is", "a", "list"]
listnolast = list[:-1]
listnofirst = list[1:]

``````

If you change 1 to 2 the first 2 characters will be removed not the second.
Hope this still helps!

``````arr=[1,3,5,7,9]
for i in range(len(arr)):
arsum = arr[:i] + arr[i + 1:]
`````` The answers/resolutions are collected from stackoverflow, are licensed under cc by-sa 2.5 , cc by-sa 3.0 and cc by-sa 4.0 .