Python基础07-数据类型：字典dict

目录

字典

字典的一般用法

字典的方法

---

字典

字典的一般用法

字典是一组用{}括起来的键值对，每个键值对用逗号分隔。

# 字典
info = {
    "Robin": "Baidu",
    "Jack": [
        "Alibaba",
        20,
        {
            "B2C": "taobao.com",
            "B2B": "1688.com",
            "C2C": "2.taobao.com",
        }
    ],
    "Pony": "Tencent",
}
print(info)

字典是无序的，因此不能用下标索引，也不能切片。只能通过键来索引值。

字典依靠键来索引，因此键必须是不可修改的。字符串、数字、元组能作为键。列表、字典等可以修改的类型不能作为键。

布尔值可以作为键，但不建议这么用。因为布尔值存储的是0和1，如果键里面也有数字0和1，布尔与数字0和1会混淆。为了避免这一混淆，布尔值不建议作为键。

info = {
    0: "zero",
    1: "one",
    2: "two",
    "k1": "v1",
    # True: "testTrue", # 布尔值不建议作为键
    # False: "testFalse", # 布尔值不建议作为键
    (11, 22): "testTuple",
    # [11, 22]: "testList",  # 可修改的值不能作为键
    # {"kk1": "vv1"}: "testDict",  # 可修改的值不能作为键
    "k2": (11, 22, 33),
    "k3":
        [
            (),
            33,
            "mysql",
            {
                "kk1": "vv1",
                "kk2": (999, 777),
                "kk3": "vv3",
            },
        ],
}

print(0, info[0])
print(1, info[1])
print(2, info[2])
print("k1", info["k1"])
print("tuple", info[(11, 22)])

print(info["k3"][3]["kk2"][0])
# 999

# 删
del info["k3"]
print(info)
# {0: 'zero', 1: 'one', 2: 'two', 'k1': 'v1', (11, 22): 'testTuple', 'k2': (11, 22, 33)}

# 改
info["k2"] = 987
print(info)
# {0: 'zero', 1: 'one', 2: 'two', 'k1': 'v1', (11, 22): 'testTuple', 'k2': 987}

# 增
info["k4"] = "vv"
print(info)
# {0: 'zero', 1: 'one', 2: 'two', 'k1': 'v1', (11, 22): 'testTuple', 'k2': 987, 'k4': 'vv'}

 字典可以迭代，默认迭代的是键，也可以指定迭代键、值、键值对。

# 迭代，默认迭代键
for k in info:
    print(k)
    pass

# 迭代，指定迭代键
for k in info.keys():
    print(k)
    pass

# 迭代，指定迭代值
for v in info.values():
    print(v)
    pass

# 迭代，指定迭代键值对
for k, v in info.items():
    print(k, v)
    pass

字典的方法

字典的clear、copy等方法就是字面意思，不再赘述。

字典的keys、values、items方法在迭代时使用，不再赘述。

dict方法，生成一个空的字典。

fromkeys方法是静态方法。用法是类名.方法名，和Java类似。用迭代器作为键的集合，生成一个字典。没有第二参数时，值都是空。有第二个参数时，值都是第二个参数。

d1 = dict()
# {}
print(d1)
d2 = dict.fromkeys("keys")
# {'k': None, 'e': None, 'y': None, 's': None}
print(d2)
d3 = dict.fromkeys([83, "k2", (13, 17)], "val")
print(d3)
# {83: 'val', 'k2': 'val', (13, 17): 'val'}

get方法。按键索引取值，如果键不存在会报错。用get方法可以避免这个问题。

用get方法，传入第一个参数键，不传第二个参数。如果键不存在，那么返回的值是None。

用get方法，传入第一个参数键，传入第二个参数默认值。如果键不存在，那么返回的值是默认值。

d4 = dict.fromkeys([83, "k2", (13, 17)], "val")
v = d4.get("k12345")
print(v)
# None
v = d4.get("k12345", 12345)
print(v)
# 12345
v = d4["k12345"]
# KeyError: 'k12345'

pop方法，删除键值对，并返回相应的值。

pop传入第一个参数键，不传第二个参数。如果键值对存在，那么字典会删除这个键值对，并返回相应值。如果键值对不存在，那么会报错。

pop传入第一个参数键，传入第二个参数默认值。如果键值对存在，那么字典会删除这个键值对，并返回相应值。如果键值对不存在，那么字典不便，返回默认值。

因此，pop的使用建议是，第二参数一定要传，没有默认值，那么就传入None。再对返回值做None判断

d5 = {
    "k1": "v1",
    "k2": "v2",
    "k3": "v3",
}
v = d5.pop("k1")
print(d5, v)
# {'k2': 'v2', 'k3': 'v3'} v1
v = d5.pop("k12345", 12345)
print(d5, v)
# {'k2': 'v2', 'k3': 'v3'} 12345

 popitem方法。移除键值对，并将键值对以2元tuple的方式返回。返回的规则是LIFO（last-in, first out）。所以后添加的键值对被先移除。如果字典本身已经为空，那么会报错。

d6 = {
    "k1": "v1",
    "k2": "v2",
    "k4": "v4",
}
d6["k3"] = "v3"
k, v = d6.popitem()
print(d6, k, v)
# {'k1': 'v1', 'k2': 'v2', 'k4': 'v4'} k3 v3

setdefault方法。设置键值对。

如果键已经存在，那么不设置，将已有键对应的值返回。

如果键不存在，那么设置，并将设置的键值对的值返回。

d7 = {
    "k1": "v1",
    "k2": "v2",
}
v = d7.setdefault("k1", "newv1")
print(d7, v)
# {'k1': 'v1', 'k2': 'v2'} v1
v = d7.setdefault("k9876", "v9876")
print(d7, v)
# {'k1': 'v1', 'k2': 'v2', 'k9876': 'v9876'} v9876

update方法。传入一个字典用来更新，如果键已经存在那么更新，如果键不存在那么新增。

d8 = {
    "k1": "v1",
    "k2": "v2",
}
d = {
    "k1": "newv1",
    "k3": "v3",
}
d8.update(d)
print(d8)
# {'k1': 'newv1', 'k2': 'v2', 'k3': 'v3'}