Remove the item at the given position in the list, and return it.
        If no index is specified, removes and returns the last item in the list.
165529
def pop(self, i=None):
        """"""
        if i is None:
            i = len(self) - 1
        val = self[i]
        del(self[i])
        return val
1063735
public ModelAdapter<?, Item> remove(int position) {
        if (mOriginalItems != null) {
            mOriginalItems.remove(getAdapterPosition(mItemAdapter.getAdapterItems().get(position)) - mItemAdapter.getFastAdapter().getPreItemCount(position));
            publishResults(mConstraint, performFiltering(mConstraint));
            return mItemAdapter;
        } else {
            return mItemAdapter.remove(position);
        }
    }
1176965
def remove_item(self, item):
        
        for idx, _item in enumerate(self.items):
            if item == _item:
                del self.items[idx]
                return True
        return False
1137508
public void removePoint(int index) {
        int numKnots = x.length;
        if (numKnots <= 2)
            return;
        float[] nx = new float[numKnots - 1];
        float[] ny = new float[numKnots - 1];
        int j = 0;
        for (int i = 0; i < numKnots - 1; i++) {
            if (i == index)
                j++;
            nx[i] = x[j];
            ny[i] = y[j];
            j++;
        }
        x = nx;
        y = ny;
    }
718929
public int remove(int index) {
        if (index < 0 || index >= size) {
            throw new IndexOutOfBoundsException(String.valueOf(index));
        }

        int old = get(index);
        
        if (index == 0) {
            // data at the front
            System.arraycopy(data, 1, data, 0, size - 1);
        } else if (size - 1 == index) {
            // no copy to make, decrementing pos "deletes" values at
            // the end
        } else {
            // data in the middle
            System.arraycopy(data, index + 1, data, index, size - (index + 1));
        }
        
        size--;
        return old;
    }
441845
def takeTopLevelItem( self, index ):
        
        item = self.topLevelItem(index)
        if item:
            self.viewWidget().scene().removeItem(item.viewItem())
            self.treeWidget().takeTopLevelItem(index)
            
            return item
        return None
933511
function remove() {
            if (list) {
                arguments.forEach(function (arg) {
                    var index = undefined;
                    while ((index = inArray(arg, list, index)) > -1) {
                        list.splice(index, 1);
                        // Handle firing indexes
                        if (firing) {
                            if (index <= firingLength) {
                                firingLength--;
                            }
                            if (index <= firingIndex) {
                                firingIndex--;
                            }
                        }
                    }
                });
            }
            return this;
        }
541473
def on_recycle_view(self, index, position):
        
        item = self.list_items[index]
        self.item_mapping[position] = item
        item.recycle_view(position)
765091
public M remove(int index){
        M item = items.remove(index);
        applyFilter();
        return item;
    }
79884
private void removeProperty(ItemState item, int indexItem)
   {
      if (indexItem == -1)
      {
         items.remove(item);
      }
      else
      {
         items.remove(indexItem);
      }
      index.remove(item.getData().getIdentifier());
      index.remove(item.getData().getQPath());
      index.remove(new ParentIDQPathBasedKey(item));
      index.remove(new IDStateBasedKey(item.getData().getIdentifier(), item.getState()));
      lastChildPropertyStates.remove(item.getData().getIdentifier());
      childPropertyStates.remove(item.getData().getIdentifier());

      Map<String, ItemState> children = lastChildPropertyStates.get(item.getData().getParentIdentifier());
      if (children != null)
      {
         children.remove(item.getData().getIdentifier());
         if (children.isEmpty())
         {
            lastChildPropertyStates.remove(item.getData().getParentIdentifier());
         }
      }

      List<ItemState> listItemStates = childPropertyStates.get(item.getData().getParentIdentifier());
      if (listItemStates != null)
      {
         listItemStates.remove(item);
         if (listItemStates.isEmpty())
         {
            childPropertyStates.remove(item.getData().getParentIdentifier());
         }
      }
   }
277549
def list_remove_by_index(l, index):
    ''''''
    if index < 0 or index >= len(l):
        raise ValueError('index out of range')
    if index == (len(l) - 1):
        l.pop()
    elif index == 0:
        l = l[1:]
    else:
        l = l[0:index] + l[index+1:]

    return l
963469
def remove(self, x):
        """"""

        def _remove(x):
            found = self.first(x)
            if found is not None:
                self._args.pop(found)

        if _is_collection(x):
            for item in x:
                _remove(x)
        else:
            _remove(x)
1276820
function removeAt(items, index) {
  var copy = items.slice();
  copy.splice(index, 1);
  return copy;
}
724026
def removeItem(self, index):
        """"""
        self._stim.removeComponent(index.row(), index.column())
1330884
def remove(self, index):
        
        data = self.data
        index = self._split(index)
        for j, c in enumerate(index):
            i = int(c) - 1
            if j + 1 == len(index):
                try:
                    del data[i]
                except IndexError:
                    raise NoItemError('.'.join(index))
            else:
                data = data[i][4]
988280
protected void removeBy(int position) {
        if (mGroupBasicAdapter != null) {
            if (position < mGroupBasicAdapter.getItemCount() && position >= 0) {
                BaseCell removeCell = mGroupBasicAdapter.getItemByPosition(position);
                removeBy(removeCell);
            }
        }
    }
55887
def remove(self, item):
        '''
        '''
        score = self._dict.pop(item, None)
        if score is not None:
            index = self._sl.rank(score)
            assert index >= 0, 'could not find start range'
            for i, v in enumerate(self._sl.range(index)):
                if v == item:
                    assert self._sl.remove_range(index + i, index+i + 1) == 1
                    return score
            assert False, 'could not find element'