Get feature names (column labels).

        Returns
        -------
        feature_names : list or None
162756
def feature_names(self):
        
        if self._feature_names is None:
            self._feature_names = ['f{0}'.format(i) for i in range(self.num_col())]
        return self._feature_names
953227
public List<String> columnNames() {
        return columnList.stream().map(Column::name).collect(toList());
    }
1282431
def _get_input_names(spec):
    
    retval = [feature.name for feature in spec.description.input]
    return retval
1133152
def get_layer_names(self):
    
    layer_names = [x.name for x in self.model.layers]
    return layer_names
1230825
def get_labels(term_ids: list) -> dict:
    
    term_labels = {}
    for term_id in term_ids:
        term = get_terms(term_id)
        term_labels[term_id] = term[0].get("label", "")

    return term_labels
629428
def get_column_names(engine: Engine, tablename: str) -> List[str]:
    
    return [info.name for info in gen_columns_info(engine, tablename)]
257949
def get_column_names(context, query):
        """"""
        table_info = context.sql_client.send(query)
        if 'fields' in table_info:
            return table_info['fields']

        return None
1218788
public List<Label> getFeatureLabels() {
        if (!isAnnotationPresent(Features.class)) {
            return Collections.emptyList();
        }

        List<Label> result = new ArrayList<>();
        for (String feature : getAnnotation(Features.class).value()) {
            result.add(createFeatureLabel(feature));
        }
        return result;
    }
723761
def names_labels(self, do_print=False):
        
        if do_print:
            for name, label in zip(self.field_names, self.field_labels):
                print('%s --> %s' % (str(name), str(label)))
        return self.field_names, self.field_labels
1291926
def __rm_names_on_csv_cols(d):
        
        _names = []
        _data = []
        for name, data in d.items():
            _names.append(name)
            _data.append(data)
        return _names, _data
221205
def featureName(self):
        
        featId = self.attributes.get("ID")
        if featId is not None:
            featId = featId[0]
        return featId
109625
def feature_names(self, feature_names):
        
        if not feature_names is None:
            # validate feature name
            if not isinstance(feature_names, list):
                feature_names = list(feature_names)
            if len(feature_names) != len(set(feature_names)):
                raise ValueError('feature_names must be unique')
            if len(feature_names) != self.num_col():
                msg = 'feature_names must have the same length as data'
                raise ValueError(msg)
            # prohibit to use symbols may affect to parse. e.g. ``[]=.``
            if not all(isinstance(f, STRING_TYPES) and f.isalnum()
                       for f in feature_names):
                raise ValueError('all feature_names must be alphanumerics')
        else:
            # reset feature_types also
            self.feature_types = None
        self._feature_names = feature_names
1009644
def level_names(self):
        
        index = self.to_index()
        if isinstance(index, pd.MultiIndex):
            return index.names
        else:
            return None
715992
def labels(self):
        
        if self._labels is None:
            self._labels = map(self.labelFormat().format, self.values())
        return self._labels
1021012
def _column_names(self):
        """"""
        index_names = set(_normalize_index_names(self._index_names))
        column_names = [col_name for col_name in self._schema_rdd.columns if
                        col_name not in index_names]
        return column_names
1320416
def fetch_column_names(self, table: str) -> List[str]:
        """"""
        return self.flavour.fetch_column_names(self, table)
361353
def column_names sheet
    
      names = []
      
      titles = sheet.column_titles
      
      sheet.each_cell_definition do |column, i|
      
        if titles[i]

          names << titles[i]
          
        elsif column.respond_to?(:value_name)
          
          names << column.value_name
          
        else
          
          names << nil
          
        end
        
      end
      
      names
      
    end