Set the column defined by `key` to the `value` provided.

        Args:
            key: The column name to set.
            value: The value to set the column to.

        Returns:
             A new QueryCompiler
160058
def setitem(self, axis, key, value):
        

        def setitem(df, internal_indices=[]):
            def _setitem():
                if len(internal_indices) == 1:
                    if axis == 0:
                        df[df.columns[internal_indices[0]]] = value
                    else:
                        df.iloc[internal_indices[0]] = value
                else:
                    if axis == 0:
                        df[df.columns[internal_indices]] = value
                    else:
                        df.iloc[internal_indices] = value

            try:
                _setitem()
            except ValueError:
                # TODO: This is a workaround for a pyarrow serialization issue
                df = df.copy()
                _setitem()
            return df

        if axis == 0:
            numeric_indices = list(self.columns.get_indexer_for([key]))
        else:
            numeric_indices = list(self.index.get_indexer_for([key]))
        prepared_func = self._prepare_method(setitem)
        if is_list_like(value):
            new_data = self.data.apply_func_to_select_indices_along_full_axis(
                axis, prepared_func, numeric_indices, keep_remaining=True
            )
        else:
            new_data = self.data.apply_func_to_select_indices(
                axis, prepared_func, numeric_indices, keep_remaining=True
            )
        return self.__constructor__(new_data, self.index, self.columns)
204137
public QueryParameters updateValue(String key, Object value) {
        this.values.put(processKey(key), value);

        return this;
    }
138371
def set_param(self, key, value):
        
        self.__dict__[key] = value
        self._parameters[key] = value
593174
def set(self, key, value):
        
        if key == "tags":
            self._set_tag(tags=value)
        else:
            if isinstance(value, dict) and key in self._requirements and isinstance(
                    self._requirements[key], dict):
                self._requirements[key] = merge(self._requirements[key], value)
            else:
                self._requirements[key] = value
685106
def set(self, key: URIRef, value: Union[Literal, BNode, URIRef, str, int], lang: Optional[str]=None):
        
        if not isinstance(value, Literal) and lang is not None:
            value = Literal(value, lang=lang)
        elif not isinstance(value, (BNode, URIRef)):
            value, _type = term._castPythonToLiteral(value)
            if _type is None:
                value = Literal(value)
            else:
                value = Literal(value, datatype=_type)
        self.graph.set((self.asNode(), key, value))
410958
def set_value(self, treeiter, column, value):
        

        value = self._convert_value(column, value)
        Gtk.TreeStore.set_value(self, treeiter, column, value)
232423
def set_item(self, key, value):
        
        keys = list(self.keys())

        # if it exists, update
        if key in keys:
            self.set_value(1,keys.index(key),str(value))

        # otherwise we have to add an element
        else:
            self.set_value(0,len(self),   str(key))
            self.set_value(1,len(self)-1, str(value))
1147453
function (key, value) {
            var self = this,
                _queryMap,
                currentValue;
            if (typeof key == 'string') {
                parseQuery(self);
                _queryMap = self._queryMap;
                currentValue = _queryMap[key];
                if (currentValue === undefined) {
                    currentValue = value;
                } else {
                    currentValue = [].concat(currentValue).concat(value);
                }
                _queryMap[key] = currentValue;
            } else {
                if (key instanceof Query) {
                    key = key.get();
                }
                for (var k in key) {
                    self.add(k, key[k]);
                }
            }
            return self;
        }
421803
def set(self, key, value, **kw):
        

        self.impl.set(key, value, **self._get_cache_kw(kw, None))
426518
def set_property(self, key, value):
        

        if type(key) is str and type(value) is str:
            self.process_pair(key, value)
        else:
            raise TypeError('Both key and value should be strings!')
1300278
def set_reference(self, key, dic):
        
        self.key = key
        self.dic = dic
15501
def set_format_key_value(self, key, value):
        ''''''
        if self.format_keys is None:
            self.format_keys = []
            self.FORMAT = {}
        if key not in self.FORMAT:
            self.format_keys.append(key)
        self.FORMAT[key] = value
109493
def setValue(self, key, value):
        
        curr = self._stack[-1]
        curr[key] = value
112745
def setValue(self, key, value):
        
        if self._customFormat:
            self._customFormat.setValue(key, value)
        else:
            super(XSettings, self).setValue(key, wrapVariant(value))
1190300
def set(self, key, value, *, flags=None):
        
        self.append({
            "Verb": "set",
            "Key": key,
            "Value": encode_value(value, flags, base64=True).decode("utf-8"),
            "Flags": flags
        })
        return self
247465
def add(self, key: str, value: str):
        
        if key in self:
            # Use super to get mutable set
            super().__getitem__(key).add(value)
        else:
            self[key] = {value}
984777
def add_key_value(self, key, value):
        
        if key == 'unique_id':
            self._unique_id = str(value)
        else:
            self._data[key] = value