Indicates that the given columns should be dropped.

        :param columns: The columns to drop
        :type columns: tuple

        :rtype: Fluent
19721
def drop_column(self, *columns):
        
        columns = list(columns)

        return self._add_command("drop_column", columns=columns)
967822
def drop(self, *cols):
        
        try:
            index = self.df.columns.values
            for col in cols:
                if col not in index:
                    self.warning("Column", col, "not found. Aborting")
                    return
                self.df = self.df.drop(col, axis=1)
        except Exception as e:
            self.err(e, self.drop, "Can not drop column")
389524
function _dropColumn(){
    self._visitingAlter = true;
    var table = self._queryNode.table;
    var result=[
      'ALTER TABLE',
      self.visit(table.toNode())
    ];
    var columns='DROP ('+self.visit(alter.nodes[0].nodes[0]);
    for (var i= 1,len=alter.nodes.length; i<len; i++){
      var node=alter.nodes[i];
      assert(node.type=='DROP COLUMN',errMsg);
      columns+=', '+self.visit(node.nodes[0]);
    }
    columns+=')';
    result.push(columns);
    self._visitingAlter = false;
    return result;
  }
773910
public Table retainColumns(Column<?>... columns) {
        List<Column<?>> retained = Arrays.asList(columns);
        columnList.clear();
        columnList.addAll(retained);
        return this;
    }
1026147
def drop(self, table):
        
        existing_tables = self.tables
        if isinstance(table, (list, set, tuple)):
            for t in table:
                self._drop(t, existing_tables)
        else:
            self._drop(table, existing_tables)
        return table
1030744
public function drop($columns)
    {
        if (!is_array($columns)) {
            $columns = [$columns];
        }

        $this->compileWheres();
        $result = $this->query->replace(function ($doc) use ($columns) {
            return $doc->without($columns);
        })->run();

        return 0 == (int) $result['errors'];
    }
1152219
private void retainOnly(int columns) {
        LOGGER.info("Sorting the columns by entropy and computing the top " + 
                    columns + " columns to retain");

        int words = termToIndex.numDimensions();
        MultiMap<Double,Integer> entropyToIndex =
            new BoundedSortedMultiMap<Double,Integer>(
                    columns, false, true, true);

        // Compute the entropy of each row and column.
        EntropyStats stats = MatrixEntropy.entropy(cooccurrenceMatrix);

        // Add the entropy values for each column.  Since the rows will be
        // concatenated as columns, they represent currently non-existing
        // columns beyond the number of words.
        for (int col = 0; col < words; ++col)
            entropyToIndex.put(stats.colEntropy[col], col);
        for (int row = 0; row < words; ++row)
            entropyToIndex.put(stats.rowEntropy[row], row+words);

        Set<Integer> indicesToKeep =
            new HashSet<Integer>(entropyToIndex.values());

        LOGGER.info("Reducing to " + columns + " highest entropy columns.");
        
        reduced = retainColumns(indicesToKeep);
        cooccurrenceMatrix = null;
    }
953619
def removeColumns(self, columnNames):
        
        model = self.tableView.model()

        if model is not None:
            model.removeDataFrameColumns(columnNames)

        self.removeColumnButton.setChecked(False)
337225
def drop_columns(records, slices):
    
    for record in records:
        # Generate a set of indices to remove
        drop = set(i for slice in slices
                   for i in range(*slice.indices(len(record))))
        keep = [i not in drop for i in range(len(record))]
        record.seq = Seq(''.join(itertools.compress(record.seq, keep)), record.seq.alphabet)
        yield record
607399
public function dropIndex($columns)
    {
        $index = new Index($columns, $this);

        $this->actions[] =  function () use ($index) {
             return $this->manipulation->drop($index);
        };

        return $this;
    }
895674
def filter_(self, columns, value):
        

        for column in columns:
            if column not in self.data.columns:
                raise ValueError("Column %s not in DataFrame columns: %s" % (column, list(self.data)))

        for column in columns:
            # Filtering on empty data series doesn't make sense at all and also would raise an error
            column_len = len(self.data[column])
            if column_len > 0 and column_len != self.data[column].isnull().sum():
                self.data = self.data[self.data[column] != value]

        return self.data
263113
public boolean hasColumns(Collection<String> columns) {
        return columns != null && this.columns.equals(new TreeSet<String>(columns));
    }
303556
def drop_if(df, fun):
    

    def _filter_f(col):
        try:
            return fun(df[col])
        except:
            return False

    cols = list(filter(_filter_f, df.columns))
    return df.drop(cols, axis=1)
609316
@SafeVarargs
  public final TableBuilder columns(String... columns) {
    if (columns == null || columns.length == 0) {
      throw new InvalidOperationException("Columns array is null or empty.");
    }
    if (tableColumns != null) {
      throw new InvalidOperationException("The table columns are already defined.");
    }
    tableColumns = columns.clone();
    return this;
  }
927883
protected void ensureColumns(List columns, List existingColumns)
    {
        if (columns == null || columns.isEmpty())
        {
            return;
        }
        
        Iterator iter = columns.iterator();

        while (iter.hasNext())
        {
            FieldHelper cf = (FieldHelper) iter.next();
            if (!existingColumns.contains(cf.name))
            {
                getAttributeInfo(cf.name, false, null, getQuery().getPathClasses());
            }
        }
    }
967380
def setColumns( self, columns ):
        
        self.setColumnCount(len(columns))
        self.setHorizontalHeaderLabels(columns)
823861
def removecolkeyword(self, columnname, keyword):
        
        if isinstance(keyword, str):
            self._removekeyword(columnname, keyword, -1)
        else:
            self._removekeyword(columnname, '', keyword)