d = {"a": 1, "b": 2}

print(d)

{'a': 1, 'b': 2}

print(len(d))

2

print(d["a"])

1

d["c"] = 3

print(d)

{'a': 1, 'b': 2, 'c': 3}

d["a"] = 10

print(d)

{'a': 10, 'b': 2, 'c': 3}

del d["b"]

print(d)

{'a': 10, 'c': 3}

print("a" in d) 

True

print("z" in d) 

False

print(d.get("a"))  

10

print(d.get("z")) 

None

print(d.get("z", 0))

0

print(d.keys())

dict_keys(['a', 'c'])

print(d.values())

dict_values([10, 3])

print(d.items())

dict_items([('a', 10), ('c', 3)])

for key in d:
    print(key)

a
c

for val in d.values():
    print(val)

10
3

for k, v in d.items():
    print(k, v)

a 10
c 3

d.clear()

print(d)

{}

d = dict(a=1, b=2)

print(d)

{'a': 1, 'b': 2}

d2 = dict([("x", 9), ("y", 8)])

print(d2)

{'x': 9, 'y': 8}

d3 = {"one": 1, "two": 2}

print(d3.pop("one"))

1

print(d3)

{'two': 2}

d3["three"] = 3

print(d3.popitem())

('three', 3)

d4 = {"a": 1}

d4.update({"b": 2})

print(d4)

{'a': 1, 'b': 2}

d4.update(c=3)

print(d4)

{'a': 1, 'b': 2, 'c': 3}

d4.update([("d", 4)])

print(d4)

{'a': 1, 'b': 2, 'c': 3, 'd': 4}

d5 = d4.copy()

print(d5)

{'a': 1, 'b': 2, 'c': 3, 'd': 4}

print(d5 is d4)

False

d5["a"] = 100

print(d4["a"]) 

1

defaults = {"x": 0, "y": 0}

print(defaults.setdefault("x", 5)) 

0

print(defaults.setdefault("z", 9))

9

print(defaults)

{'x': 0, 'y': 0, 'z': 9}

print({x: x**2 for x in range(3)})

{0: 0, 1: 1, 2: 4}

names = ["a", "b"]

scores = [10, 20]

print(dict(zip(names, scores)))

{'a': 10, 'b': 20}

print(dict.fromkeys(["a", "b", "c"], 0))

{'a': 0, 'b': 0, 'c': 0}

for i in dict.fromkeys("abc"):
    print(i)

a
b
c

d = {"a": 1}

print("a" in d)

True

print("z" not in d)

True

d = {"x": 1}

d["x"] += 1

print(d)

{'x': 2}

print(type(d))

<class 'dict'>

print(list(d))

[]

print(list(d.items()))

[]

print(sorted(d)) 

[]

d = {"a": 1, "b": {"c": 2}}

print(d["b"]["c"])

2

d = {"a": 1, "b": 2}

d2 = {"b": 3, "c": 4}

d.update(d2)

print(d)

{'a': 1, 'b': 3, 'c': 4}

print({k:v for k,v in d.items() if v > 2})

{'b': 3, 'c': 4}

print({v:k for k,v in d.items()})

{1: 'a', 3: 'b', 4: 'c'}

nested = {"outer": {"inner": 1}}

print(nested["outer"]["inner"])

1

d = {}

d["new"] = d.get("new", 0) + 1

print(d)

{'new': 1}

freq = {}

for ch in "banana":
    freq[ch] = freq.get(ch, 0) + 1
print(freq)

{'b': 1, 'a': 3, 'n': 2}

data = [("a", 1), ("b", 2)]

d = dict(data)

print(d)

{'a': 1, 'b': 2}

print({k:len(k) for k in ["apple", "banana"]})

{'apple': 5, 'banana': 6}

print({i:chr(i) for i in range(65, 70)})

{65: 'A', 66: 'B', 67: 'C', 68: 'D', 69: 'E'}

print({chr(i):i for i in range(65, 70)})

{'A': 65, 'B': 66, 'C': 67, 'D': 68, 'E': 69}

pairs = ["a=1", "b=2"]

print({p.split("=")[0]: int(p.split("=")[1]) for p in pairs})

{'a': 1, 'b': 2}

print(all(k in d for k in ["a", "b"]))

True

print(any(v == 2 for v in d.values()))

True

print(sum(d.values()))

3

print(min(d.values()))

1

print(max(d.values()))

2

print(len(d.keys()) == len(set(d.keys())))

True

data = {"a": 10, "b": 20}

print({k: v*2 for k, v in data.items()})

{'a': 20, 'b': 40}

d = {"x": 10}

print(d.get("y", "not found"))

not found

d = dict()

print(bool(d)) 

False

print(dict(a=1, b=2) == {"a": 1, "b": 2})

True

x = {"a": 1, "b": 2}

y = {"b": 3, "c": 4}

z = {**x, **y}

print(z) 

{'a': 1, 'b': 3, 'c': 4}

d = {"a": 1, "b": 2}

print(hash(frozenset(d.items())))

-8457517723523400311

print(list(d))

['a', 'b']

print(list(d.values()))

[1, 2]

print({k: v for k, v in d.items() if k != "b"})

{'a': 1}

from collections import defaultdict
dd = defaultdict(int)
dd["a"] += 1
print(dd)

defaultdict(<class 'int'>, {'a': 1})

dd = defaultdict(list)
dd["x"].append(10)
print(dd)

defaultdict(<class 'list'>, {'x': [10]})

from collections import OrderedDict
od = OrderedDict()
od["a"] = 1
od["b"] = 2
print(od)

OrderedDict({'a': 1, 'b': 2})

od.move_to_end("a")
print(od)

OrderedDict({'b': 2, 'a': 1})

from collections import Counter
c = Counter("mississippi")
print(c)

Counter({'i': 4, 's': 4, 'p': 2, 'm': 1})

print(c.most_common(2))

[('i', 4), ('s', 4)]

c.update("i")
print(c)

Counter({'i': 5, 's': 4, 'p': 2, 'm': 1})

c.update("i")
print(c)

Counter({'i': 6, 's': 4, 'p': 2, 'm': 1})

print(c["s"])

4

print(c.items())

dict_items([('m', 1), ('i', 6), ('s', 4), ('p', 2)])

c2 = Counter("miss")

print(c + c2)

Counter({'i': 7, 's': 6, 'm': 2, 'p': 2})

print(c - c2)

Counter({'i': 5, 's': 2, 'p': 2})

print(c & c2)

Counter({'s': 2, 'm': 1, 'i': 1})

print(c | c2)

Counter({'i': 6, 's': 4, 'p': 2, 'm': 1})

print(dict(sorted(c.items(), key=lambda x: -x[1])))

{'i': 6, 's': 4, 'p': 2, 'm': 1}

d = {"x": [1, 2], "y": [3]}

print(d["x"][1])

2

d["z"] = []

d["z"].append(99)

print(d)

{'x': [1, 2], 'y': [3], 'z': [99]}

d.setdefault("k", []).append(1)

print(d)

{'x': [1, 2], 'y': [3], 'z': [99], 'k': [1]}

print(isinstance(d, dict))

True

nested = {"x": {"y": {"z": 1}}}

print(nested["x"]["y"]["z"])

1

flat = {f"{k1}_{k2}": v for k1, inner in nested.items() for k2, v in inner["y"].items()}

print(flat)

{'x_z': 1}

print({x: x % 2 == 0 for x in range(5)})

{0: True, 1: False, 2: True, 3: False, 4: True}

d = {"a": None}

print(d.get("a") is None)

True

print({i: i**0.5 for i in range(1, 6)})

{1: 1.0, 2: 1.4142135623730951, 3: 1.7320508075688772, 4: 2.0, 5: 2.23606797749979}

print({k: v for k, v in zip("abc", range(3))})

{'a': 0, 'b': 1, 'c': 2}

data = ["a", "b", "c"]

print(dict.fromkeys(data, 0))

{'a': 0, 'b': 0, 'c': 0}

print({x: bool(x % 2) for x in range(6)})

{0: False, 1: True, 2: False, 3: True, 4: False, 5: True}

a = {"one": 1}

b = {"two": 2}

merged = a | b

print(merged)

{'one': 1, 'two': 2}

a |= {"three": 3}

print(a)

{'one': 1, 'three': 3}

a.update(four=4)

print(a)

{'one': 1, 'three': 3, 'four': 4}

d = {"x": 1}

print(d.pop("x", "missing"))

1

print(d.pop("x", "missing")) 

missing

d = {"x": 1, "y": 2}

print([*d])

['x', 'y']

print({**{"a": 1}, **{"b": 2}})

{'a': 1, 'b': 2}

from types import MappingProxyType
read_only = MappingProxyType(d)
print(read_only["y"])

2

keys = "abc"

vals = range(3)

print(dict(zip(keys, vals)))

{'a': 0, 'b': 1, 'c': 2}

k, v = list(d.items())[0]

print(k, v)

x 1

print(list(d.values())[0])

1

print(len(set(d.values())))

2

print(any(k.startswith("x") for k in d))

True

print({k: v for k, v in d.items() if k != "x"})

{'y': 2}

print({k.upper(): v for k, v in d.items()})

{'X': 1, 'Y': 2}

print({k: v for k, v in d.items() if isinstance(v, int)})

{'x': 1, 'y': 2}

print(all(isinstance(k, str) for k in d))

True

print({k: v for k, v in zip("abc", [1, 2, 3]) if v % 2})

{'a': 1, 'c': 3}

print({k: v for k, v in enumerate("xyz")})

{0: 'x', 1: 'y', 2: 'z'}

d = {"a": [1, 2], "b": [3, 4]}

print(sum(sum(v) for v in d.values()))

10

print({k: v[::-1] for k, v in d.items()})

{'a': [2, 1], 'b': [4, 3]}

print({k: sum(v) for k, v in d.items()})

{'a': 3, 'b': 7}