python基本数据类型--字典（dict）_python变量类型dict

目录

字典的定义

访问元素的值

修改元素的值

新增元素

python内置函数

内置函数len

内置函数min

内置函数max

内置函数del

字典类内置函数

字典实例创建新字典

内置函数fromkeys

清空字典

内置函数clear

复制字典

内置函数copy

获取指定键对应的值

内置函数get

内置函数setdefault

字典视图

内置函数items

内置函数keys

内置函数values

删除字典中的元素

内置函数pop

内置函数popitem

更新字典

内置函数update

字典 比较运算符

比较运算符（==）

比较运算符（!=）

字典 成员运算符

成员运算符（in）

成员运算符（not in）

字典 身份运算符

身份运算符（is）

身份运算符（is not）

要注意内存地址相同的可变对象

---

字典的定义

        用{}作为边界逗号作为分隔符，采用键：值一一对应的方式。其中键必须是不可变的数据类型（整型、浮点型、字符串、元组、冻结集合），值可以是任意的python对象，如：{}，{1: 2, "a": 5}等等，是可迭代的数据类型，可以被修改。我们可以使用下面4种方式来定义列表。

        第一种：直接使用{}

dict1 = {1: 123, 'name': '爆笑蛙', (1, 2): ['a', 'b', 'c']}
print(dict1)  # {1: 123, 'name': '爆笑蛙', (1, 2): ['a', 'b', 'c']}

字典dict1的第一个元素的键是1值是123，第二个元素的键是'name'值是'爆笑蛙'，第三个元素的键是(1, 2)值是['a', 'b', 'c']。

        字典中元素的键一定要是一个不可变的数据类型（整型、浮点型、字符串、元组、冻结集合），因为我们需要通过元素的键去访问元素的值，所以字典中每个元素的键都必须具有唯一性（每个元素的键都不能和其他元素的键相同）。如果元素的键是随时都有可能发生改变的数据，那我们将无法通过键去访问到正确的值（有可能多个元素的键在某种情况下变成同一个值）。所以字典在定义的时候，出现多个元素的键相同时，将只保留最后一个键相同的元素的值。

dict1 = {'name': 123, 1: 'abc', 'name': ['a', 'b'], 2: 111, 'name': '爆笑蛙'}
print(dict1)  # {'name': '爆笑蛙', 1: 'abc', 2: 111}

dict1在定义的时候有3个元素的键是相同的，但键具有唯一性。所以python保留了键相同的第一个元素的键和最后一个元素的值，可以理解为是在给第一个元素更新值。

        第二种：使用dict函数和关键字参数

dict1 = dict(name='爆笑蛙', number=123)
print(dict1)  # {'name': '爆笑蛙', 'number': 123}

dict函数会把传入的关键字参数当作元素的键，而且是字符串类型的键。把关键字对应的值当作元素的值，可以是任意python对象。

        第三种：使用dict函数和双元组列表

list1 = [(1, 123), ('name', '爆笑蛙'), ((1, 2), [1, 2, 3])]
dict1 = dict(list1)
print(dict1)  # {1: 123, 'name': '爆笑蛙', (1, 2): [1, 2, 3]}

list1是一个双元组列表，list1中的每一个元素都是拥有两个元素的元组。dict函数会把list1中的每一双元组取出来，把双元组中的第一个元素当作键，第二个元素当作值，变成一个字典。前提是双元组中的第一个元素是不可变的数据类型，否则python会报错。

        第四种：使用字典类静态函数fromkeys

dict1 = dict.fromkeys('abc', 1)
print(dict1)  # {'a': 1, 'b': 1, 'c': 1}
dict2 = dict.fromkeys([1, 2, 3], 'go')
print(dict2)  # {1: 'go', 2: 'go', 3: 'go'}

fromkeys函数接收两个参数，第一个参数为一个可迭代对象，第二个参数为字典中每个元素的默认值。fromkeys会把可迭代对象中的每一个元素都取出来，当作字典中每一个元素的键，每一个元素的值即我们传入的默认值。最后在返回生成的字典。前提是可迭代对象中的每一个元素都是不可变的数据类型，否则python会报错。

访问元素的值

        我们可以把字典中每个元素的键当作索引，去访问对应元素的值。

dict1 = {'name': '爆笑蛙', 'number': 49}
print(dict1['name'])  # 爆笑蛙
print(dict1['number'])  # 49

使用第一个元素的键'name'访问到了第一个元素的值'爆笑蛙'，使用第二个元素的值'number'访问到了第二个元素的值49。

        当索引的键跟字典中所有元素的键都不相同时，python会报错。

dict1 = {'name': '爆笑蛙', 'number': 49}
print(dict1['hello'])

执行结果如下：

错误显示键错误，因为在字典dict1中不存在键为'hello'的元素。

        因为字典需要用键当作索引去访问元素的值，所以字典不能像字符串、列表和元组一样被索引和切片。因为索引下标是整型，整型又可以当作字典中元素的键， 所以dict1[0]到底是输出第一个元素还是输出键为0的元素的值，这就会产生冲突了。

修改元素的值

        我们可以把字典中每个元素的键当作索引，去修改对应元素的值。

dict1 = {'name': '爆笑蛙', 'number': 49}
print(dict1)  # {'name': '爆笑蛙', 'number': 49}
dict1['name'] = '小明'
print(dict1)  # {'name': '小明', 'number': 49}

使用第一个元素的键'name'访问到了第一个元素的值'爆笑蛙'，然后用赋值运算符（=）给它重新赋值为'小明'，第一个元素的值就变成了'小明'。

        当索引的键跟字典中所有元素的键都不相同时，就会给字典新增一个元素。

新增元素

        当我们需要给字典新增元素时，就把元素的键放到字典的索引中，然后用赋值运算符（=）把值传进去。

dict1 = {'name': '爆笑蛙', 'number': 49}
print(dict1)  # {'name': '爆笑蛙', 'number': 49}
dict1['sex'] = '男'
print(dict1)  # {'name': '爆笑蛙', 'number': 49, 'sex': '男'}

通过键访问元素的值，如果键不存在就会报错。通过键给元素赋值，如果键不存在就会新增一个元素。

python内置函数

内置函数len

        我们向len函数传入一个字典，它会返回这个字典的长度（整型）。

dict1 = {'name': '爆笑蛙', 'number': 49}
print(len(dict1))  # 2

字典dict1中只有两个元素，所以打印的结果为2。

内置函数min

        我们向min函数传入一个字典，它会返回这个字典中最小的键，前提是这个字典中所有元素的键必须具有可比性。比如所有元素的键全都是数字，全都是字符串。

dict1 = {'name': '爆笑蛙', 'number': 49, 'sex': '男'}
print(min(dict1))  # name
dict2 = {0: 'haha', 1: 123, 2: 'hello'}
print(min(dict2))  # 0

如果这个字典中元素的键不具有可比性就会报错，例如整型和字符串是不能比较大小的。

dict1 = {'name': '爆笑蛙', 'number': 49, 1: '男'}
print(min(dict1))

执行结果如下：

报错显示类型错误，字符串和整型不能比较大小。

内置函数max

        我们向max函数传入一个字典，它会返回这个字典中最大的键，前提是这个字典中所有元素的键必须具有可比性。比如所有元素的键全都是数字，全都是字符串。

dict1 = {'name': '爆笑蛙', 'number': 49, 'sex': '男'}
print(max(dict1))  # sex
dict2 = {0: 'haha', 1: 123, 2: 'hello'}
print(max(dict2))  # 2

内置函数del

        函数del可以删除字典中的元素，也可以删除整个字典。我们使用键去索引的方式，找到字典中的某一个元素，然后使用del函数就可以把它从字典中删除。

dict1 = {'name': '爆笑蛙', 'number': 49, 'sex': '男'}
print(dict1)  # {'name': '爆笑蛙', 'number': 49, 'sex': '男'}
del dict1['sex']
print(dict1)  # {'name': '爆笑蛙', 'number': 49}

我们还可以使用del删除整个字典，当我们删除整个字典之后，就不能再使用这个字典了，因为这个字典已经不存在了。当我们是用del删除字典后再去打印这个字典就会报错。

dict1 = {'name': '爆笑蛙', 'number': 49, 'sex': '男'}
del dict1
print(dict1)

执行结果如下：

 报错显示变量名错误，变量dict1未定义。因为dict1已经被整个删除掉了，所以在内存中找不到dict1。 

字典类内置函数

        字典类内置函数是在字典这个类型中定义的函数，所以想要使用这些函数，前提是使用的对象必须是一个字典。

字典实例创建新字典

内置函数fromkeys

        fromkeys函数接收两个参数，第一个参数为一个可迭代对象，第二个参数为字典中每个元素的默认值。fromkeys会把可迭代对象中的每一个元素都取出来，当作字典中每一个元素的键，每一个元素的值即我们传入的默认值。最后在返回生成的字典。前面我们已经讲过使用fromkeys函数来创建字典了，但前面将的是使用字典类直接创建，现在我们用字典类的实例。类和类的实例的区别就是，一个后面没括号一个后面有括号。

# 字典类
print(dict)  # <class 'dict'>
# 字典类的实例
print(dict())  # {}

一个类就相当于是一台未通电的电脑，里面虽然有一些运算逻辑但什么也干不了；类的实列就像是给这个电脑通电后的状态，可以帮我们处理很多事情。但为什么fromkeys函数可以被字典类直接执行呢？因为fromkeys函数是字典类中的一个静态函数。一个类中的静态函数可以不跟这个类有任何关系，甚至可以把这个静态函数直接写到类外面。但是为了方便我们调用和封装，我们常常会把一些跟一个类中的属性不相关的函数，以静态函数的方式写到类中。

dict1 = {'name': '爆笑蛙', 'number': 49, 'sex': '男'}
dict2 = dict1.fromkeys('abc')
print(dict2)  # {'a': None, 'b': None, 'c': None}
print(dict1)  # {'name': '爆笑蛙', 'number': 49, 'sex': '男'}

dict1在使用fromkeys函数创建一个新字典后，dict1本身没有发生任何改变，这就是因为类中的静态函数跟类中的属性没有关系。当我们不给fromkeys函数传入第二个参数是，生成的字典中元素的默认值为None，None也是python中的基本数据类型，表示什么也没有。

清空字典

内置函数clear

        函数clear可以删除字典中所有的元素，把字典变成空字典。

dict1 = {'name': '爆笑蛙', 'number': 49, 'sex': '男'}
print(dict1)  # {'name': '爆笑蛙', 'number': 49, 'sex': '男'}
dict1.clear()
print(dict1)  # {}

复制字典

内置函数copy

        copy函数可以复制当前字典，并返回一个复制字典，我们需要用一个变量来接收返回回来的复制字典。

dict1 = {'name': '爆笑蛙', 'number': 49, 'sex': '男'}
dict2 = dict1.copy()
print(dict1)  # {'name': '爆笑蛙', 'number': 49, 'sex': '男'}
print(dict2)  # {'name': '爆笑蛙', 'number': 49, 'sex': '男'}

获取指定键对应的值

内置函数get

        get函数接收两个参数，第一个参数为键，第二个参数为默认值。当字典中存在传入的键时，返回键对应的值；当字典中不存在传入的键时，返回默认值。get函数和直接使用键当索引去获取值的区别在于，当键不存在时get函数不会报错。

dict1 = {'name': '爆笑蛙', 'number': 49, 'sex': '男'}
print(dict1.get('name', 'hello'))  # 爆笑蛙

当字典中不存在传入的键时，就会返回传入的默认值。

dict1 = {'name': '爆笑蛙', 'number': 49, 'sex': '男'}
print(dict1.get(1, 'hello'))  # hello

当没有传入默认值时，会返回None。

dict1 = {'name': '爆笑蛙', 'number': 49, 'sex': '男'}
print(dict1.get(1))  # None

内置函数setdefault

        setdefault函数接收两个参数，第一个参数为键，第二个参数为默认值。当字典中存在传入的键时，返回键对应的值；当字典中不存在传入的键时，把传入的键和默认值作为一个新元素加入到字典中，并返回默认值。

dict1 = {'name': '爆笑蛙', 'number': 49, 'sex': '男'}
value = dict1.setdefault('name', 'haha')
print(value)  # 爆笑蛙
print(dict1)  # {'name': '爆笑蛙', 'number': 49, 'sex': '男'}

        当字典中不存在传入的键时，把传入的键和默认值作为一个新元素加入到字典中，并返回默认值。

dict1 = {'name': '爆笑蛙', 'number': 49, 'sex': '男'}
value = dict1.setdefault(1, 'haha')
print(value)  # haha
print(dict1)  # {'name': '爆笑蛙', 'number': 49, 'sex': '男', 1: 'haha'}

当没有传入默认值时，会返回None，字典中新添加的元素的值也为None。

dict1 = {'name': '爆笑蛙', 'number': 49, 'sex': '男'}
value = dict1.setdefault(1)
print(value)  # None
print(dict1)  # {'name': '爆笑蛙', 'number': 49, 'sex': '男', 1: None}

字典视图

内置函数items

        函数items会返回当前字典的项目视图对象，这个项目视图对象中的内容是一个二元组列表。二元组列表中的每一个元素，是字典中每一个元素的键和值组成的二元组。项目视图对象是可迭代的，list函数可以把项目视图对象中的二元组列表提取出来，也可以使用for循环来迭代。

dict1 = {'name': '爆笑蛙', 'number': 49, 'sex': '男'}
items = dict1.items()
print(items)  # dict_items([('name', '爆笑蛙'), ('number', 49), ('sex', '男')])
list1 = list(items)
print(list1)  # [('name', '爆笑蛙'), ('number', 49), ('sex', '男')]

内置函数keys

        函数keys会返回当前字典的键视图对象，这个键视图对象中的内容是一个列表。列表中的每一个元素，是字典中每一个元素的键。键视图对象是可迭代的，list函数可以把键视图对象中的列表提取出来，也可以使用for循环来迭代。

dict1 = {'name': '爆笑蛙', 'number': 49, 'sex': '男'}
keys = dict1.keys()
print(keys)  # dict_keys(['name', 'number', 'sex'])
list1 = list(keys)
print(list1)  # ['name', 'number', 'sex']

内置函数values

        函数values会返回当前字典的值视图对象，这个值视图对象中的内容是一个列表。列表中的每一个元素，是字典中每一个元素的值。值视图对象是可迭代的，list函数可以把值视图对象中的列表提取出来，也可以使用for循环来迭代。

dict1 = {'name': '爆笑蛙', 'number': 49, 'sex': '男'}
values = dict1.values()
print(values)  # dict_values(['爆笑蛙', 49, '男'])
list1 = list(values)
print(list1)  # ['爆笑蛙', 49, '男']

删除字典中的元素

内置函数pop

        我们给pop函数传入一个键，它会删除字典中键对应的元素。并把删除的这个元素的值返回回来，我们可以使用一个变量来接收也可以不接收。

dict1 = {'name': '爆笑蛙', 'number': 49, 'sex': '男'}
values = dict1.pop('name')
print(values)  # 爆笑蛙
print(dict1)  # {'number': 49, 'sex': '男'}

当传入的键不存在时，会报错。

dict1 = {'name': '爆笑蛙', 'number': 49, 'sex': '男'}
values = dict1.pop('hello')
print(values)
print(dict1)

执行结果如下：

报错显示键错误，因为字典dict1中没有一个元素的键是'hello'。

内置函数popitem

        函数popitem可以删除字典中最后一个元素，并返回由这个元素的键和值组成的二元组。

dict1 = {'name': '爆笑蛙', 'number': 49, 'sex': '男'}
tuple_2 = dict1.popitem()
print(tuple_2)  # ('sex', '男')
print(dict1)  # {'number': 49, 'sex': '男'}

        当字典为空字典时会报错。

dict1 = {}
tuple_2 = dict1.popitem()
print(tuple_2)
print(dict1)

执行结果如下：

报错显示键错误，popitem处理的字典为空。

更新字典

内置函数update

        我们给update函数传入一个字典dict_，它会把dict_中的元素更新到当前字典中。如果dict_中的键和当前字典中的键有相同的情况，则把dict_中的值更新到当前字典。

dict1 = {'name': '爆笑蛙', 'number': 49, 'sex': '男'}
dict2 = {'name': '小明'}
dict1.update(dict2)
print(dict1)  # {'name': '小明', 'number': 49, 'sex': '男'}

dict_中存在当前字典中不存在的键时，给当前字典新增元素。

dict1 = {'name': '爆笑蛙', 'number': 49, 'sex': '男'}
dict2 = {'name': '小明', 'hello': 123, 1: 'haha'}
dict1.update(dict2)
print(dict1)  # {'name': '小明', 'number': 49, 'sex': '男', 'hello': 123, 1: 'haha'}

字典 比较运算符

        我们不能用比较运算符来比较两个字典的大小，只能用来判断两个字典是否相等。

比较运算符（==）

        ==用于判断两个字典是否相等，如果相等返回True，不相等返回False。

dict1 = {'name': '爆笑蛙', 'number': 49, 'sex': '男'}
dict2 = {'name': '小明', 'hello': 123, 1: 'haha'}
print(dict1 == dict2)  # False
dict3 = {'name': '爆笑蛙', 'number': 49}
dict4 = {'name': '爆笑蛙', 'number': 49}
print(dict3 == dict4)  # True

比较运算符（!=）

        !=用于判断两个字典是否不相等，如果不相等返回True，相等返回False。

dict1 = {'name': '爆笑蛙', 'number': 49, 'sex': '男'}
dict2 = {'name': '小明', 'number': 49, 'sex': '男'}
print(dict1 != dict2)  # True
dict3 = {'name': '爆笑蛙', 'number': 49}
dict4 = {'name': '爆笑蛙', 'number': 49}
print(dict3 != dict4)  # False

字典 成员运算符

        成员运算符可以用来判断某个键是某个否在字典中。

成员运算符（in）

        当某个键在字典中存在时，返回True；在字典中找不到相同的键时，返回False。

dict1 = {'name': '爆笑蛙', 'number': 49, 'sex': '男'}
print('name' in dict1)  # True
print(1 in dict1)  # False

字典dict1中第一个元素的键是'name'，所以'name' in dict1返回True。字典dict1中没有一个元素的键是1，所以1 in dict1返回False。

成员运算符（not in）

        当某个键不在字典中时，返回True；在字典中找到相同的键时，返回False。

dict1 = {'name': '爆笑蛙', 'number': 49, 'sex': '男'}
print('name' not in dict1)  # False
print(1 not in dict1)  # True

字典dict1中第一个元素的键是'name'，所以'name' not in dict1返回False。字典dict1中没有一个元素的键是1，所以1 not in dict1返回True。

字典 身份运算符

        身份运算符可以判断两个字典的内存地址是否一致。因为字典是可变的数据类型，所以即使两个字典的值是相等的，它们的内存地址也可能不同。

身份运算符（is）

        is用于判断左右两个对象的内存地址是否相同，如果相同返回True，不同返回False。举个例子，请看下面的代码：

dict1 = {'name': '爆笑蛙', 'number': 49, 'sex': '男'}
dict2 = {'name': '爆笑蛙', 'number': 49, 'sex': '男'}
print(id(dict1))  # 2047598402368
print(id(dict2))  # 2047598402432
print(dict1 is dict2)  # False

dict1和dict2是相等的，但它们的内存地址不同。它们存储在内存中不同的地方，这就是可变数据类型的特性。

        我们使用字典类内置函数copy来复制字典，复制出来的字典和原字典内存地址也不相同。

dict1 = {'name': '爆笑蛙', 'number': 49, 'sex': '男'}
dict2 = dict1.copy()
print(id(dict1))  # 2087385570112
print(id(dict2))  # 2087385570176
print(dict1 is dict2)  # False

        通过赋值运算符（=）赋值出来的字典内存地址是相同的。

dict1 = {'name': '爆笑蛙', 'number': 49, 'sex': '男'}
dict2 = dict1
print(id(dict1))  # 2027189771072
print(id(dict2))  # 2027189771072
print(dict1 is dict2)  # True

身份运算符（is not）

        is not用于判断左右两个对象的内存地址是否不同，如果不同返回True，相同返回False。举个例子，请看下面的代码：

dict1 = {'name': '爆笑蛙', 'number': 49, 'sex': '男'}
dict2 = {'name': '爆笑蛙', 'number': 49, 'sex': '男'}
print(id(dict1))  # 2317930601280
print(id(dict2))  # 2317930601344
print(dict1 is not dict2)  # True
dict3 = {1.1: 'hello'}
dict4 = dict3.copy()
print(id(dict3))  # 2317930601664
print(id(dict4))  # 2317930981056
print(dict3 is not dict4)  # True
dict5 = {(1, 2): 'world'}
dict6 = dict5
print(id(dict5))  # 2317930981120
print(id(dict6))  # 2317930981120
print(dict5 is not dict6)  # False

要注意内存地址相同的可变对象

         当两个字典的内存地址相同时，我们修改其中任意一个字典，另一个字典也会跟着改变。

dict1 = {'name': '爆笑蛙', 'number': 49, 'sex': '男'}
dict2 = dict1
dict2['name'] = '小明'
print(dict1)  # {'name': '小明', 'number': 49, 'sex': '男'}
print(dict2)  # {'name': '小明', 'number': 49, 'sex': '男'}
dict1[1] = 'hello'
print(dict1)  # {'name': '小明', 'number': 49, 'sex': '男', 1: 'hello'}
print(dict2)  # {'name': '小明', 'number': 49, 'sex': '男', 1: 'hello'}

两个对象的内存地址相同时，其中一个对象修改了内存中的值。另一个对象去相同的内存地址取值，取出来的就是修改后的值。