> ## Documentation Index > Fetch the complete documentation index at: https://site.aspect.build/llms.txt > Use this file to discover all available pages before exploring further. # Dict `function` **dict.clear** 
        
          def dict.clear() -> None
[dict.clear](https://github.com/bazelbuild/starlark/blob/master/spec.md#dict·clear): clear a dictionary `D.clear()` removes all the entries of dictionary D and returns `None`. It fails if the dictionary is frozen or if there are active iterators. ``` x = {"one": 1, "two": 2} x.clear() x == {} ``` `function` **dict.get** 
        
          def dict.get(
          key: typing.Any,
          default: typing.Any = ...,
          /
          ) -> typing.Any
[dict.get](https://github.com/bazelbuild/starlark/blob/master/spec.md#dict·get): return an element from the dictionary. `D.get(key[, default])` returns the dictionary value corresponding to the given key. If the dictionary contains no such value, `get` returns `None`, or the value of the optional `default` parameter if present. `get` fails if `key` is unhashable. ``` x = {"one": 1, "two": 2} x.get("one") == 1 x.get("three") == None x.get("three", 0) == 0 ``` `function` **dict.items** 
        
          def dict.items() -> list\[(typing.Any, typing.Any)]
[dict.items](https://github.com/bazelbuild/starlark/blob/master/spec.md#dict·items): get list of (key, value) pairs. `D.items()` returns a new list of key/value pairs, one per element in dictionary D, in the same order as they would be returned by a `for` loop. ``` x = {"one": 1, "two": 2} x.items() == [("one", 1), ("two", 2)] ``` `function` **dict.keys** 
        
          def dict.keys() -> list
[dict.keys](https://github.com/bazelbuild/starlark/blob/master/spec.md#dict·keys): get the list of keys of the dictionary. `D.keys()` returns a new list containing the keys of dictionary D, in the same order as they would be returned by a `for` loop. ``` x = {"one": 1, "two": 2} x.keys() == ["one", "two"] ``` `function` **dict.pop** 
        
          def dict.pop(
          key: typing.Any,
          default: typing.Any = ...,
          /
          ) -> typing.Any
[dict.pop](https://github.com/bazelbuild/starlark/blob/master/spec.md#dict·pop): return an element and remove it from a dictionary. `D.pop(key[, default])` returns the value corresponding to the specified key, and removes it from the dictionary. If the dictionary contains no such value, and the optional `default` parameter is present, `pop` returns that value; otherwise, it fails. `pop` fails if `key` is unhashable, or the dictionary is frozen or has active iterators. ``` x = {"one": 1, "two": 2} x.pop("one") == 1 x == {"two": 2} x.pop("three", 0) == 0 x.pop("three", None) == None ``` Failure: ``` {'one': 1}.pop('four') # error: not found ``` `function` **dict.popitem** 
        
          def dict.popitem() -> (typing.Any, typing.Any)
[dict.popitem](https://github.com/bazelbuild/starlark/blob/master/spec.md#dict·popitem): returns and removes the first key/value pair of a dictionary. `D.popitem()` returns the first key/value pair, removing it from the dictionary. `popitem` fails if the dictionary is empty, frozen, or has active iterators. ``` x = {"one": 1, "two": 2} x.popitem() == ("one", 1) x.popitem() == ("two", 2) x == {} ``` Failure: ``` {}.popitem() # error: empty dict ``` `function` **dict.setdefault** 
        
          def dict.setdefault(
          key: typing.Any,
          default: typing.Any = ...,
          /
          ) -> typing.Any
[dict.setdefault](https://github.com/bazelbuild/starlark/blob/master/spec.md#dict·setdefault): get a value from a dictionary, setting it to a new value if not present. `D.setdefault(key[, default])` returns the dictionary value corresponding to the given key. If the dictionary contains no such value, `setdefault`, like `get`, returns `None` or the value of the optional `default` parameter if present; `setdefault` additionally inserts the new key/value entry into the dictionary. `setdefault` fails if the key is unhashable or if the dictionary is frozen. ``` x = {"one": 1, "two": 2} x.setdefault("one") == 1 x.setdefault("three", 0) == 0 x == {"one": 1, "two": 2, "three": 0} x.setdefault("four") == None x == {"one": 1, "two": 2, "three": 0, "four": None} ``` `function` **dict.update** 
        
          def dict.update(
          pairs: typing.Iterable\[(typing.Any, typing.Any)] | dict = ...,
          /,
          \*\*kwargs: typing.Any
          ) -> None
[dict.update](https://github.com/bazelbuild/starlark/blob/master/spec.md#dict·update): update values in the dictionary. `D.update([pairs][, name=value[, ...])` makes a sequence of key/value insertions into dictionary D, then returns `None.` If the positional argument `pairs` is present, it must be another `dict`, or some other iterable. If it is another `dict`, then its key/value pairs are inserted into D. If it is an iterable, it must provide a sequence of pairs (or other iterables of length 2), each of which is treated as a key/value pair to be inserted into D. For each `name=value` argument present, the name is converted to a string and used as the key for an insertion into D, with its corresponding value being `value`. `update` fails if the dictionary is frozen. ``` x = {} x.update([("a", 1), ("b", 2)], c=3) x.update({"d": 4}) x.update(e=5) x == {"a": 1, "b": 2, "c": 3, "d": 4, "e": 5} ``` `function` **dict.values** 
        
          def dict.values() -> list
[dict.values](https://github.com/bazelbuild/starlark/blob/master/spec.md#dict·values): get the list of values of the dictionary. `D.values()` returns a new list containing the dictionary's values, in the same order as they would be returned by a `for` loop over the dictionary. ``` x = {"one": 1, "two": 2} x.values() == [1, 2] ```