Numpy arrays have a fixed size, hence you cannot simply delete an element from them. The simplest way to achieve what you want is to use slicing:

a = a[3:]

This will create a new array starting with the 4th element of the original array.

For certain scenarios, slicing is just not enough. If you want to create a subarray consisting of specific elements from the original array, you can use another array to select the indices:

>>> a = arange(10, 20)
>>> a[[1, 4, 5]]
array([11, 14, 15])

So basically, a[[1,4,5]] will return an array that consists of the elements 1,4 and 5 of the original array.

If you use numpy arrays, then use them as arrays and not as lists

numpy does comparison elementwise for the entire array, which can then be used to select the relevant subarray. This also removes the need for the inner loop.

>>> a = np.array([[datetime(2010, 10, 26, 11, 5, 28, 157404), 14.1],
                  [datetime(2010, 10, 26, 11, 5, 30, 613066), 17.2],
                  [datetime(2010, 10, 26, 11, 5, 31, 613066), 17.2],
                  [datetime(2010, 10, 26, 11, 5, 32, 613066), 17.2],
                  [datetime(2010, 10, 26, 11, 5, 33, 613066), 17.2],
                  [datetime(2010, 10, 26, 11, 5, 38, 613066), 17.2]],
                          dtype=object)
>>> start = datetime(2010, 10, 26, 11, 5, 28, 157405)
>>> end = datetime(2010, 10, 26, 11, 5, 33, 613066)

>>> (a[:,0] > start)&(a[:,0] < end)
array([False,  True,  True,  True, False, False], dtype=bool)
>>> a[(a[:,0] > start)&(a[:,0] < end)]
array([[2010-10-26 11:05:30.613066, 17.2],
       [2010-10-26 11:05:31.613066, 17.2],
       [2010-10-26 11:05:32.613066, 17.2]], dtype=object)

just to make sure we still have datetimes in there:

>>> b = a[(a[:,0] > start)&(a[:,0] < end)]
>>> b[0,0]
datetime.datetime(2010, 10, 26, 11, 5, 30, 613066)

NumPy arrays are not resizable and do not allow dynamic typing. This is because efficiency is sought, using compiled C code below in the most straightforward way possible. This implies that resizing an array means creating a new array. This is why del does not work. There are two ways to remove elements from a NumPy array, both involve creating a copy of the array and it is this copy that is returned (because as mentioned above it is not possible to do inplace): - Using the method numpy.delete >>> import numpy as np # Eliminar el primer elemento: >>> a = np.array([1, 2, 3, 4]) >>> a = np.delete(a, 0) >>> a array([2, 3, 4]) # Eliminar el último elemento >>> a = np.array([1, 2, 3, 4]) >>> a = np.delete(a, a.shape[0] - 1) >>> a array([1, 2, 3]) # Eliminar el primero y el último: >>> a = np.array([1, 2, 3, 4]) >>> a = np.delete(a, (0, a.shape[0] - 1)) >>> a array([2, 3]) It receives three parameters: The array as the first argument. The index (or iterable with the indexes) of the element(s) to be deleted as the second argument. The axis on which the third party acts. Note: In the future (according to the developers themselves) np.delete will allow the use of negative indices, so we will be able to change a = np.delete(a, a.shape[0] - 1) by a = np.delete(a,- 1) . - Use slicing techniques on the array. This option is usually more efficient, especially if we only remove from the beginning or the end of the array: >>> import numpy as np #Eliminar el primer elemento >>> a = np.array([1, 2, 3, 4]) >>> a = a[1:] >>> a array([2, 3, 4]) # Eliminar el último elemento >>> a = np.array([1, 2, 3, 4]) >>> a = a[:-1] >>> a array([1, 2, 3]) # Eliminar el primero y el último: >>> a = np.array([1, 2, 3, 4]) >>> a = a[1:-1] >>> a array([2, 3]) If you intended to use the element returned by list.pop In this case you must first obtain the element by indexing and then apply the elimination with one of the two methods. It would also be possible to convert the array to a list or a queue (if add and remove operations are going to predominate at the ends), bearing in mind that there may be implications for type switching and efficiency penalties when switching to using a list or similar (in addition to not being able to use NumPy's own methods with it): >>> import numpy as np >>> a = np.array([1, 2, 3, 4]) >>> a = a.tolist() >>> a [1, 2, 3, 4] >>> a.pop() >>> a [1, 2, 3] >>> del(a[0]) >>> a >>> [2, 3] If you are not interested in using NumPy arrays you should simply make your function return a list. If I0s is simply the result of concatenating two lists, as you seem to indicate in the code, just do just that: >>> I0smallst = [1] >>> I0bigst = [2, 5] >>> I0s = I0smallst + I0bigst >>> [1, 2, 5]

The issue you're encountering arises because you're modifying the stack list while iterating over it, and the indices of the items in the list are shifting as a result of deletions. However, in your provided code, the loop for iterating and printing the stack is separate from the loop where deletions are handled, so it shouldn't cause a problem in this specific case. In the provided code snippet, the core logic is contained within a while True loop that continuously prompts the user for an index to delete until an empty string is entered. When an index is provided, it is checked against the bounds of the list, and if valid, the item at that index is removed using del stack[index]. Here's a slightly cleaned-up version of your code with better structure and explanation to ensure it functions as intended: # Initial stack of elements stack = [3, 4, 5, 22] # Start of the infinite loop to process user inputs while True: # Ask the user for an index to remove input1 = input("Give me a number (or press Enter to exit): ") # Break the loop if the input is an empty string if input1 == "": break try: # Convert the input to an integer and adjust for zero-based index index = int(input1) - 1 # Check if the index is within the valid range if 0 <= index < len(stack): # Delete the element at the provided index del stack[index] else: # Notify the user if the index is out of bounds print("Invalid index. Please enter a valid index.") except ValueError: # Handle cases where the input is not an integer print("Invalid input. Please enter a valid integer.") # Display the remaining elements in the stack print("Remaining elements in stack:") for element in stack: print(element) Explanation: Loop: The code runs in a continuous loop until the user enters an empty string to exit. Input Handling: It collects an index from the user, checks if it's within the list's bounds, and if so, deletes the corresponding element. Error Handling: The code handles invalid inputs gracefully, either non-integer values or out-of-range indices. State Update: After each operation, it prints the current state of the stack. This structure ensures that the indices you're working with are always up-to-date after each deletion, preventing any off-by-one or out-of-bound errors.

Since it finds the object, c_id is definitely in related_to field. I believe you are getting this error because c_id is not an int type but string type. You should first convert it to int:

c_id = int(c_id)
obj=notes.objects.get(id=n_id,related_to__contains=[c_id])
....

The problem is that when you do ("${pids[@]/$pid}"), it substitutes the $pid item in the array with an empty string (""). So the item isn't actually removed from the array, it's just replaced with an empty string item.

I'm guessing that after some pids gets "removed" from the array, the next cycle of for pid in "${pids[@]}", the following line will produce an error, since at least some of the $pid variables will be empty:

if [ -z "$(ps -p $pid -o pid=)" ]

This ps probably throws some error to stderr, but the output (STDOUT) of the command would be empty, so it will decrement $i by 1, and eventually $i will probably drop below zero, and since it will never be 0, the loop will never stop.

since all of the items of the in the array are numbers, you fix this by removing the quotes from the following line:

pids=("${pids[@]/$pid}")

So instead it would be:

pids=(${pids[@]/$pid})

Without the quotes the empty elements are removed from the array.

Here's a short example:

$ array=( 1 2 3 )

$ echo "${array[@]/1}"
 2 3
# Notice that the first item is replaced with an empty string

$ echo ${array[@]/1}
2 3
# Without the quotes, the empty string is removed

Notice this only works because the items in the array are numbers. It will not work if the array contains strings and spaces.

In addition, this method only substitutes substrings (and not necessarily whole array items), so for instance, if pids=( "1", "123" ), and pid=1, the result of (${pids[@]/1}) would be ( "23" ) (removing the "1" from "123", and only the "23" will remain.

See the following answer for additional details and a method to remove an item from any array regardless of the content of the array.

Disclaimer:

This answer only explains why your script didn't work as expected. My suggestion will probably make your script work, but it's not written in the most optimal way. There are many changes that could make the script cleaner and more efficient, but I'm not going into it in this answer.