1、字典是Python中唯一的映射类型

2、字典包含两个要素：键（key）和值（value）他们是成对出现的，用大括号括起来，多对存在时用逗号隔开

①创建空字典：

>>> dict2={}
>>> dict2
{}

②创建并查询

注意：
每个键与值用冒号隔开（:），每对用逗号，每对用逗号分割，整体放在花括号中（{}）。
键必须独一无二，但值则不必。
值可以取任何数据类型，但必须是不可变的，如字符串，数或元组。

>>> dict1={1:'one',2:'two',3:'three'}
>>> dict1[3]
'three'

可以用元组和dict（）去创建#dict括号里只能传入一个参数

>>> dict3=dict(((1,'one'),(2,'two'),(3,'three')))
>>> dict3
{1: 'one', 2: 'two', 3: 'three'}

可以用键值=value和dict（）去创建

dict4=dict(西施='沉鱼',昭君='落雁',貂蝉='闭月')
>>> dict4
{'西施': '沉鱼', '貂蝉': '闭月', '昭君': '落雁'}

注意前面键值不能是字符串

>>> dict5=dict('西施'='沉鱼','昭君'='落雁','貂蝉'='闭月')
SyntaxError: keyword can't be an expression

3、修改 

>>> dict4=dict(西施='沉鱼',昭君='落雁',貂蝉='闭月')
>>> dict4
{'西施': '沉鱼', '貂蝉': '闭月', '昭君': '落雁'}
>>> dict4['貂蝉']='你好'
>>> dict4
{'西施': '沉鱼', '貂蝉': '你好', '昭君': '落雁'}

4、增添

>>> dict4=dict(西施='沉鱼',昭君='落雁',貂蝉='闭月')
>>> dict4
{'西施': '沉鱼', '貂蝉': '闭月', '昭君': '落雁'}
>>> dict4['玉环']='羞花'
>>> dict4
{'西施': '沉鱼', '玉环': '羞花', '貂蝉': '闭月', '昭君': '落雁'}

与序列不同，序列中访问不存在的值会报错，而字典中会自动添加 

5、删除

 

-----------------------------------------------测试题----------------------------------------

测试题：

0. 当你听到小伙伴们在谈论“映射”、“哈希”、“散列”或者“关系数组”的时候，事实上他们就是在讨论什么呢？

答：是的，事实上他们就是在讨论我们这一讲介绍的“字典”，都是一个概念！

 

1. 尝试一下将数据（'F': 70, 'C': 67, 'h': 104, 'i': 105, 's': 115）创建为一个字典并访问键 'C' 对应的值？

方法一：


aaa=dict((('F',70),("C",67),("h",104),('i',105),('s',115))) print(aaa["C"])


方法二：


aaa={'F':70,"C":67,"h":104,'i':105,'s':115} print(aaa['C'])


2. 用方括号（“[]”）括起来的数据我们叫列表，那么使用大括号（“{}”）括起来的数据我们就叫字典，对吗？

答：不对

例如：

>>> NotADict = {1,2,3,4,5}
>>> type(NotADict)
<class 'set'>

不难发现，虽然我们用大括号（“{}”）把一些数据括起来了，但由于没有反映出这些数据有映射的关系，所以创建出
来的不是字典，而是叫’set’的东西，那’set’到底又是啥玩意儿呢？请看第027讲 | 集合：在我的世界里，你就是唯
一！

 

3. 你如何理解有些东西字典做得到，但“万能的”列表却难以实现（臣妾做不到T_T）？

例如：

>>> brand = ['李宁','耐克','阿迪达斯','鱼C工作室']
>>> slogan = ['一切皆有可能','Just do it','Impossible is nothing','让编程改变世界']
>>> print('鱼C工作室的口号是：',slogan[brand.index('鱼C工作室')])
鱼C工作室的口号是： 让编程改变世界

列表brand、slogan的索引和相对的值是没有任何关系的，我们可以看出唯一有联系的就是两个列表间，索引号相同的
元素是有关系的（品牌对应口号嘛），所以这里我们通过brand.index('鱼C工作室')这样的语句，间接的实现通过品牌
查找对应的口号的功能。
  
这确实是一种可实现方法，呃……但用起来呢，多少有些别扭，效率还不高咧。况且Python是以简洁为主，这样子的实
现肯定是不能让人满意的，所以呢，我们需要有字典这种映射类型的出现：

>>> dict1 = {'李宁':'一切皆有可能','耐克':'Just do it','阿迪达斯':'Impossible is nothing','鱼C工作室':'让编程改变世界'}
>>> print('鱼C工作室的口号是：',dict1['鱼C工作室'])
鱼C工作室的口号是： 让编程改变世界

 

4. 下边这些代码，他们都在执行一样的操作吗？你看得出差别吗？

>>> a = dict(one=1,two=2,three=3)
>>> b = {'one':1,'two':2,'three':3}
>>> c = dict(zip(['one','two','three'],[1,2,3]))
>>> d = dict([('two',2),('one',1),('three',3)])
>>> d = dict({'three':3,'one':1,'two':2})

 

是的，他们都在创建字典：a = dict(one=1, two=2, three=3)，呃，我是看不出差别啦~

实际运行效果为：

>>> a
{'two': 2, 'three': 3, 'one': 1}
>>> b
{'two': 2, 'three': 3, 'one': 1}
>>> c
{'two': 2, 'three': 3, 'one': 1}
>>> d
{'two': 2, 'three': 3, 'one': 1}

说明Python的dict()是无序的，即dict的遍历顺序与初始化顺序是不一致的。

------------------------------------------------------------------------------------------------------------------------

字典中的内置函数

1、fromkeys()#两个参数，第一个是键值，第二个是value（默认为none），会返回一个创造好的新字典

>>> dict1={}
>>> dict1.fromkeys((1,2,3))
{1: None, 2: None, 3: None}
>>> dict1.fromkeys((1,2,3),('one','two','three'))
{1: ('one', 'two', 'three'), 2: ('one', 'two', 'three'), 3: ('one', 'two', 'three')}
>>> dict2={}
>>> dict2.fromkeys(range(1,4),range(3,4))
{1: range(3, 4), 2: range(3, 4), 3: range(3, 4)}

2、访问字典

与序列不同的是，字典中通常是通过键值来访问而不是值，而序列中往往是通过值来访问

keys(),访问键值

values(),访问value

items()，以元祖形式访问字典

注意：如果不重新赋值，dict不发生改变

>>> dict4={}
>>> dict4.fromkeys(range(1,6),'赞')
{1: '赞', 2: '赞', 3: '赞', 4: '赞', 5: '赞'}
>>> dict4
{}
>>> dict4=dict4.fromkeys(range(1,6),'赞')
>>> dict4
{1: '赞', 2: '赞', 3: '赞', 4: '赞', 5: '赞'}

 

>>> dict4
{1: '赞', 2: '赞', 3: '赞', 4: '赞', 5: '赞'}
>>> for eachkey in dict4.keys():
	print(eachkey)

1
2
3
4
5
>>> for eachvalue in dict4.values():
	print(eachvalue)

赞
赞
赞
赞
赞
>>> for eachitem in dict4.items():
	print(eachitem)

(1, '赞')
(2, '赞')
(3, '赞')
(4, '赞')
(5, '赞')

与序列不同的是，字典中通常是通过键值来访问而不是值，而序列中往往是通过值来访问

get(),通过键值访问，不存在则不打印

>>> dict4
{1: '赞', 2: '赞', 3: '赞', 4: '赞', 5: '赞'}
>>> dict4(1)
Traceback (most recent call last):
  File "<pyshell#33>", line 1, in <module>
    dict4(1)
TypeError: 'dict' object is not callable
>>> dict4.get(4)
'赞'
>>> dict4.get(6)
>>> dict4.get(4,'ddd')
'赞'
>>> dict4.get(6,'six')
'six'
>>> dict4=dict4.get(6,'six')
>>> dict4
'six'
>>>

in 和not in

>>> dict5={}
>>> dict5=dict5.fromkeys(range(1,7),'hello')
>>> dict5
{1: 'hello', 2: 'hello', 3: 'hello', 4: 'hello', 5: 'hello', 6: 'hello'}
>>> 1 in dict5
True
>>> 10 in dict5
False

3、清空字典

建议使用clear()

>>> dict5
{1: 'hello', 2: 'hello', 3: 'hello', 4: 'hello', 5: 'hello', 6: 'hello'}
>>> dict5.clear()
>>> dict5
{}

4、关于拷贝的问题

浅拷贝：申请了新内存的拷贝

通过查询地址位置可看清赋值和‘copy’之间不同

>>> a={1:'one',2:'two',3:'three'}
>>> b=a.copy()
>>> c=a
>>> a
{1: 'one', 2: 'two', 3: 'three'}
>>> b
{1: 'one', 2: 'two', 3: 'three'}
>>> c
{1: 'one', 2: 'two', 3: 'three'}
>>> id(a)
2859131329800
>>> id(b)
2859131330440
>>> id(c)
2859131329800
>>>

5、pop()和popitem()

popitem随机弹出

>>> a
{1: 'one', 2: 'two', 3: 'three'}
>>> a.pop(1)
'one'
>>> a.popitem()
(2, 'two')

6.setdefault（），类似get（），不同的是当键值不存在时会自动创建

>>> b
{1: 'one', 2: 'two', 3: 'three'}
>>> b.setdefault(1)
'one'
>>> b.setdefault(4)
>>> b
{1: 'one', 2: 'two', 3: 'three', 4: None}
>>> b.setdefault(4,'four')
>>> b
{1: 'one', 2: 'two', 3: 'three', 4: None}
>>> b.setdefault(5,'five')
'five'
>>> b
{1: 'one', 2: 'two', 3: 'three', 4: None, 5: 'five'}

update(),用一个字典去更新另一个

>>> b
{1: 'one', 2: 'two', 3: 'three', 4: None, 5: 'five'}
>>> d={'new1':'11','new2':'22','new3':'33'}
>>> b.update(d)
>>> b
{1: 'one', 2: 'two', 3: 'three', 4: None, 5: 'five', 'new2': '22', 'new3': '33', 'new1': '11'}