Set feature names (column labels).

        Parameters
        ----------
        feature_names : list or None
            Labels for features. None will reset existing feature names
185841
def feature_names(self, feature_names):
        
        if feature_names is not None:
            # validate feature name
            try:
                if not isinstance(feature_names, str):
                    feature_names = [n for n in iter(feature_names)]
                else:
                    feature_names = [feature_names]
            except TypeError:
                feature_names = [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
                       not any(x in f for x in set(('[', ']', '<')))
                       for f in feature_names):
                raise ValueError('feature_names may not contain [, ] or <')
        else:
            # reset feature_types also
            self.feature_types = None
        self._feature_names = feature_names
1339022
def _all_feature_names(name):
    # type: (Union[str, bytes, List[Dict]]) -> List[str]
    
    if isinstance(name, bytes):
        return [name.decode('utf8')]
    elif isinstance(name, list):
        return [x['name'] for x in name]
    else:
        return [name]
334854
def _set_labels(self, axes, dimensions, xlabel=None, ylabel=None, zlabel=None):
        
        xlabel, ylabel, zlabel = self._get_axis_labels(dimensions, xlabel, ylabel, zlabel)
        if self.invert_axes:
            xlabel, ylabel = ylabel, xlabel
        if xlabel and self.xaxis and 'x' in self.labelled:
            axes.set_xlabel(xlabel, **self._fontsize('xlabel'))
        if ylabel and self.yaxis and 'y' in self.labelled:
            axes.set_ylabel(ylabel, **self._fontsize('ylabel'))
        if zlabel and self.zaxis and 'z' in self.labelled:
            axes.set_zlabel(zlabel, **self._fontsize('zlabel'))
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
889743
def _add_dict_row(self, feature_dict, key=None):
        
        self._update_internal_column_state(set(feature_dict.keys()))

        # reset the row memoization
        self._row_memo = {}

        if key is not None:
            if key in self._row_name_idx:
                self._rows[self._row_name_idx[key]] = feature_dict
                return
            else:
                self._row_name_idx[key] = len(self._rows)
                self._row_name_list.append(key)

        self._rows.append(feature_dict)
256012
def set_column_names(self, column_names):
        
        if len(self._rows):
            raise NotImplementedError("You can't manually set columns once data has been added")

        self._update_internal_column_state(column_names)
364118
public void setFeatures(List<Feature> features) {
        this.mFeatures.clear();
        if (features != null) {
            this.mFeatures.addAll(features);
        }
    }
1117366
public void setFacetNames(java.util.Collection<String> facetNames) {
        if (facetNames == null) {
            this.facetNames = null;
            return;
        }

        this.facetNames = new java.util.ArrayList<String>(facetNames);
    }
852817
def addObject(self, featureIndices, name=None):
    
    if name is None:
      name = len(self.objects)

    sequence = []
    for f in featureIndices: sequence += [(0, f,)]

    self.objects[name] = sequence
980353
def set_gene_name(self,name):
    
    self._options = self._options._replace(gene_name = name)
940485
def set_name_filters(self, name_filters):
        """"""
        self.name_filters = name_filters
        self.fsmodel.setNameFilters(name_filters)
651029
public void setNames(java.util.Collection<String> names) {
        if (names == null) {
            this.names = null;
            return;
        }

        this.names = new com.amazonaws.internal.SdkInternalList<String>(names);
    }
268191
def _parse_feature_names(feature_names, new_names):
        """"""
        if isinstance(feature_names, set):
            return FeatureParser._parse_names_set(feature_names)

        if isinstance(feature_names, dict):
            return FeatureParser._parse_names_dict(feature_names)

        if isinstance(feature_names, (tuple, list)):
            return FeatureParser._parse_names_tuple(feature_names, new_names)

        raise ValueError('Failed to parse {}, expected dictionary, set or tuple'.format(feature_names))
1007579
def set_feature_name(self, feature_name):
        
        if feature_name != 'auto':
            self.feature_name = feature_name
        if self.handle is not None and feature_name is not None and feature_name != 'auto':
            if len(feature_name) != self.num_feature():
                raise ValueError("Length of feature_name({}) and num_feature({}) don't match"
                                 .format(len(feature_name), self.num_feature()))
            c_feature_name = [c_str(name) for name in feature_name]
            _safe_call(_LIB.LGBM_DatasetSetFeatureNames(
                self.handle,
                c_array(ctypes.c_char_p, c_feature_name),
                ctypes.c_int(len(feature_name))))
        return self
1048368
def transcript_names(self, contig=None, strand=None):
        
        return self._all_feature_values(
            column="transcript_name",
            feature="transcript",
            contig=contig,
            strand=strand)
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
557329
@Api
	public void setNamedRoles(Map<String, List<NamedRoleInfo>> namedRoles) {
		this.namedRoles = namedRoles;
		ldapRoleMapping = new HashMap<String, Set<String>>();
		for (String roleName : namedRoles.keySet()) {
			if (!ldapRoleMapping.containsKey(roleName)) {
				ldapRoleMapping.put(roleName, new HashSet<String>());
			}
			for (NamedRoleInfo role : namedRoles.get(roleName)) {
				ldapRoleMapping.get(roleName).add(role.getName());
			}
		}
	}