———43———————————————————————————————————————

字典

键值对，无序可变序列。每个元素都是成对存在的，通过键来获取，删除，更新对应的值

键 是任意的，不可变的数据，整数，浮点数，字符串，元组都可以作为键，但列表，字典，集合等可变的对象不能作为键。键不能重复。  #如果重复了，后边的键会覆盖前面的键。

值可以是任意的数据。可以重复。

典型的字典定义方法：

a = {'name':'gaoqi','age':18,'job':programmer'}          #其中，name age job是键，冒号后边的是值

dict()

b = dict(name='gaoqi',age=18,job='programmer')

a = dict([("name","gaoqi"),("age",18)])

c = {}                                     #空的字典对象

c = dict()                               #空的字典对象

zip()创建字典对象                     #通过zip压缩成一个字典

k = ['name','age','job']                           #全是键

v = ['gaoqi',18,'teacher']                       #全是值

d = dict(zip(k,v))                         #zip(键，值)

d

{'name':'gaoqi','age':18,'job':'teacher'}         

fromkeys创建值为空的字典

a = dict.fromkeys['name','age','job']

a

{'name':None,'age':None,'job':None}               #只有键没有值。

——————44———————————————————————————————————

字典元素的访问

a = {'name':'gaoqi','age':18,'job':programmer'}            #定义一个字典

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

通过键获得值：

a['name']

'gaoqi'

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

通过get()方法获得“值” 推荐使用，优点：指定键不存在，返回None；也可以设定指定键不存在时默认返回的对象，推荐使用 get()获取值对象          get比较灵活，当没有这个键时：

a.get('sex')

None

aget('sex','一个男人')

'一个男人'

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

items()                 列出所有的键值对

a.items()

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

keys()                    #列出所有的键

values()                   #列出所有的值

len()                       #统计键值对的个数

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

检测一个键是否在字典中

"name" in a                           #name是否在字典中

True

—————45————————————————————————————————————

字典元素的添加，修改，删除

a = {'name':'gaoqi','age':18,'job':programmer'}

新增键值对：如果已经存在键，则覆盖，如果没有，则新增

a['address']='西三旗一号院'

a['age']=16

a

a = {'name':'gaoqi','age':16,'job':programmer','address':'西三旗一号院'}

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

update()                 将一个字典所有的键值对全都添加给旧字典对象上。如果重复键，则直接覆盖

b = {'name':'chaoba','money':1000,'sex':'男的'}

a.update(b)                          #把b中的键值对都添加给a

a

{'name':'chaoba','age':16,'job':programmer','address':'西三旗一号院','money':1000,'sex':'男的'}

b

{'name':'chaoba','money':1000,'sex':'男的'}                        #b字典不变

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

字典的删除：

del()                         删除一个特定的键值对

del(a['name'])                  #删除字典a的name键值对

c = a.pop('age')                      删除字典a中的age，并返回这个键对应的值，

c

16

clear()                                  删除所有的键值对

a.clear()                       

a

{}                                           #只剩下空的字典a

popitem()                            随机删除和返回该键值对。

a = {'name':'gaoqi','age':18,'job':''teacher}

a.popitem()

('age',18)                                     #随机删除一个键值对。中间是逗号

a

{'name':'gaoqi','job':'teacher'}

_________46__________________________________________________________________

序列解包

可用于列表，元组，字典；方便我们对多个变量赋值

当用于字典时:

s = {'name':'gaoqi','age':18,'job':'teacher'}

a,b,c = s                        #序列解包

a

'name'                              #a对应的是name键

b

'age'

e,d,f = s,values()             #

e

'gaoqi'                         #依次对应的是值

h,i,j = s.items()                #依次对应键值对

h

('name', 'gaoqi')                         #输出的是一个元组

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

元组列表时：

x,y,z=(20,30,10)

x

20

(a,b,c)=(9,8,10)

a

9

[a,b,c]=[10,20,30]

a

10

____________47____________________________________________________________

表格数据用字典和列表存储，并实现访问

r1 = {'name':'高小一','age':18,'salary':'20000','city':'北京'}

r2 = {'name':'高小二','age':19,'salary':'20000','city':'上海'}

r3 = {'name':'高小五','age':20,'salary':'10000','city':'深圳'}

tb = [r1,r2,r3]

#获得第二行的人的薪资

print(tb[1].get('salary'))

#打印表中所有的薪资：

for i in range(len(tb)):       #i-->0,1,2

    print(tb[i].get('salary'))

#打印表的所有数据

for i in range(len(tb)):

    print(tb[i].get('name'),tb[i].get('age'),tb[i].get('salary'),tb[i].get('city'))

_______48__________________________________________________________________

字典核心底层原理（重要）

 存储

字典对象的核心是散列表。散列表是一个稀疏数组（总是有空白元素的数组）数组的每个单元叫 bucket。每个 bucket有两部分，一个是键对象的引用，一个是值对象的引用。

所有bucket结构和大小一致，可以通过偏移量来读取指定bucket

一个bucket包括：key和value。即键和值。通过前面的索引来管理

————49—————————————————————————————————————

取

…………

用法总结:

键查询方法很快

往字典里添加新建可能导致扩容，导致散列表中键的次序变化，因此，不要在遍历字典的同时进行字典的修改。

字典在内存中开销巨大，是典型的空间换时间

————50——————————————————————————————————————

集合

集合是，无序可变，元素不能重复。实际上，集合底层是字典实现，集合的所有元素都是字典中的键对象，所以是不能重复的唯一的

定义一个集合：

a = {3,5,7,"gg"}

a

{3,5,7,'gg'}

a.add(3)                          #添加一个元素3

a

{3,5,7,'gg'}                           #由于已经有元素3了，不会再加

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

可以用set()，将列表，元组等可迭代对象转换成集合。如果原来的数据存在重复的数据，则只保留一个

b = set(a)                            #把a中的所有元素弄到集合b里；集合不分顺序，所以b的顺序是乱的。-------------------------------

删除集合中的元素：

remove()删除指定元素；

a.remove(2)                                 #删除集合a中的元素2

clear()清空整个集合

a.clear()                                      #清空集合a

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

集合的相关操作：并集，交集，差集

a|b                   #并集                         a跟b所有加起来的

a&b                     #交集                   a与b重复的

a-b                        #差集        a-b后，a中剩下的

a.union(b)                     #并集

a.intersection(b)            #并集

a.difference(b)                    #差集

———————————————————————————————————————————