神奇的python系列5：python基础数据类型三（字典）

第一步 字典

字典(dict)是python中唯⼀的⼀个映射类型.他是以{ }括起来的键值对组成.字典用于存储数据，字典的查找快一些。

字典dict    键值对数据     dic = {'键':'值'}

字典是不可哈希的,就是可变的数据。

可变的数据不能哈希，不可变的数据能哈希。

已知的可哈希(不可变)的数据类型: int, str, tuple, bool

不可哈希(可变)的数据类型: list, dict, set

注意: key必须是不可变(可哈希)的. value没有要求.可以保存任意类型的数据

python3.6 版本以上：字典默认是有序的, 咱们怎么写的就怎么打印出来

注意:dict保存的数据不是按照我们添加进去的顺序保存的. 是按照hash表的顺序保存的. ⽽hash表 不是连续的. 所以不能进⾏切片⼯作. 它只能通过key来获取dict中的数据

#字典的键:  不可变数据类型   键不能重复,重复的话就会把值覆盖
#字典的值:  可以随意
dic = {1:['邓','新','龙'],
       2:'靖哥哥',
       14:'张翔宁',
       True:'我兜里',
       (1,2):'草山',
       '25':'黄蓉',
       '你好':'试试'
       }
# print(dic['25'])    # 通过键去查找值
# print(dic[2])    # 通过键去查找值

第二步 字典的增删改查

增的方法：

1.dic['键'] = '值'

dic[11] = '小米'
print(dic)

2.dic.setdefault('键') 

dic.setdefault('键','值')          # 先查看返回None的时候 进行添加 返回值就不进行添加

dic.setdefault(11,'华为')   # 17 键  华为 值
# 1.先去字典中通过11这个键去查有没有值  就是None
# 2.如果是值  就不进行添加
# 3.如果是None, 就添加   返回的是添加的值

# print(dic)
# print(dic.setdefault(17))

3.dict.fromkeys('可迭代对象')    # 坑   不写值默认是None  写值得时候如果是可变数据类型就需要小心了

删的方法：

1.del dic   # 删除整个字典

2.del dic[1]

del dic[1]  # 通过键删除
print(dic)

3.dict.pop('键','找不到时的提示语句')

print(dic.pop('25'))    # pop 通过指定键删除  pop也有返回值,  返回的是被删除的值
print(dic)

4.dict.popitem()

dic.popitem()   # 随机删除  python3.6 删除最后一个   3.5 中随机删除
print(dic)

5.dic.clear()

dic.clear()  # 清空
print(dic)

改的方法：

1.dict.update()   在括号里级别高于update前面的

dic1 = {'33':'jj','44':'TT'}
dic2 = {'33':'gg','66':'pp'}
dic1.update(dic2)

2.dict['键'] = '值'      # 只有在字典中才是修改 , 没有在字典中就是增

dic1 = {'33':'jj','44':'TT'}
dic2 = {'33':'gg','66':'pp'}

dic2['33'] = 'tsp'   #是字典中没有的时候才叫增，如果字典中这个键存在就叫做修改
print(dic2)

查的方法：

1.print(dict['键'])        

dic2 = {'33':'gg','66':'pp'}
print(dic2[2])          # 通过键查找   如果键不存在就报错
print(dic2.setdefault('33'))   # 不存在返回None

2.print(dict.get('键','查找不到的提示语句'))

dic2 = {'33':'gg','66':'pp'}
print(dic2.get(2))        # 通过键查找    如果键不存在不会报错,返回None

3.dict.setdefault('键')       #查

dic2 = {'33':'gg','66':'pp'}
print(dic2.setdefault('33'))   # 不存在返回None

第三步 字典的其他操作

1.输出键

#第一种
for i in dic2:              #输出的键
    print(i)

#第二种
for i in dic2.keys():       #输出的键
    print(i)

2.输出值

#第一种
for i in dic2:              #输出的值
    print(dic2.get(i))

#第二种
for i  in dic2.values():    #输出的值
    print(i)

3.items   # 所以的键值

for i in dic2.items():      #以元组形式输出所有的key和value
    print(i)

4.循环输出key和value

for i in dic2:              #循环输出所有的key和value
    print(i,dic2[i])

注意：

keys        # 所有的键 高仿列表
values     # 所有的值 高仿列表
items      # 所以的键值 元祖形式

print(dic2.keys())   # 高仿列表 dict_keys(['33', '66'])  不能使用下标
print(dic2.values())   # 高仿列表 dict_values(['gg', 'pp'])  不能使用下标

for k,v in dic2.items():   # k,v =  ('33','gg')
   print(k)
   print(v)

keys()   # 获取所有的键   高仿列表
values()  # 获取所有的值   高仿列表
item()   # 获取键值  以元祖的形式显示

解构

a,b,c = 1,2,3    # 1,2,3   True,False,True  '456'  [7,8,9]  (7,8,9) {'1':8,'2':9,'3':0}
print(a)
print(b)
print(c)

a,b = 1,2
print(a,b)
结果:
1 2
 
a,b = ('你好','世界')
print(a,b)
结果:
你好 世界
 
 
a,b = ['你好','大飞哥']
print(a,b)
结果:
你好 世界
 
 
a,b = {'汪峰':'北京北京','王菲':'天后'}
print(a,b)
结果:
汪峰 王菲

# 面试题:

a = 10
b = 20
a,b = b,a      # 10000%会被问到
print(b)  # 10
print(a)  # 20

补充：

###############################这是坑##############################################
# dic3 = dict.fromkeys([1,2,3,4,5,6,7,8,9,0],[1,2,3])
# #第一个参数是键 要是可迭代的对象
# #第二个参数是值, 值是无所谓   是因为创建的新字典的值用的都是一个  值是一个可变数据类型
# print(dic3)
# dic3[3].append(9)
# print(dic3)

##################################################################################

dic2 = {'33':'gg','66':'pp'}
ret = dic2.get('99','你傻啊,没有还要拿')   #如果字典里没有这个键值对那么返回的是None
ret = dic2.pop('99')   #如果字典里没有这个键值对，则会报错
print(ret)

第四步 字典的嵌套

dic = {'汪峰':{'光头强':'电锯',
              '葛慧倩':'熊大',
              '国际章':'熊二'},
        '陈冠希':{'张柏芝':'喜剧之王',
               '阿娇':'千机变'},
        '韦小宝':{'建宁':'公主',
               '龙儿':'教主夫人',
               '双儿':{'大双':'榴莲','小双':'椰子'},
               '阿珂':'刺客'}}
dic1 = dic['陈冠希']['阿娇']
print(dic1)
print(dic['韦小宝']['双儿'])
print(dic['韦小宝']['双儿']['小双'])

集合：set集合是python的⼀个基本数据类型. ⼀般不是很常⽤. set中的元素是不重复的.⽆序的.里⾯的元素必须是可hash的(int, str, tuple,bool), 我们可以这样来记. set就是dict类型的数据但是不保存value, 只保存key. set也⽤{}表示。

注意:set集合中的元素必须是可hash的, 但是set本⾝是不可hash得.set是可变的.

集合  set  se = {1,2,3}  天然去重  内容要求不可变数据

#使⽤这个特性.我们可以使⽤set来去掉重复

# 给list去重复
lst = [45, 5, "哈哈", 45, '哈哈', 50]
lst = list(set(lst)) # 把list转换成set, 然后再转换回list
print(lst)

set集合的增删改查：

增:

se.add('内容')
se.update('可迭代对象')

删：

se.remove('内容')
se.pop()   # 默认删除第一个
del se    # 删除整个集合
se.clear()  # 清空set集合.需要注意的是set集合如果是空的. 打印出来是set() 因为要和dict区分的.

改：集合就是先删后增

# set集合中的数据没有索引. 也没有办法去定位⼀个元素. 所以没有办法进⾏直接修改.
# 我们可以采⽤先删除后添加的⽅式来完成修改操作
s = {"刘嘉玲", '关之琳', "王祖贤","张曼⽟", "李若彤"}
# 把刘嘉玲改成赵本⼭
s.remove("刘嘉玲")
s.add("赵本⼭")
print(s)

查：

# set是⼀个可迭代对象. 所以可以进⾏for循环
for el in s:
　　print(el)

其他操作：

# 交集   &
# 并集   |
# 差集   -
# 反差集 ^
# 子集 <
# 超级 >

set集合本⾝是可以发⽣改变的. 是不可hash的. 我们可以使⽤frozenset来保存数据. frozenset是不可变的. 也就是⼀个可哈希的数据类型

s = frozenset(["赵本⼭", "刘能", "⽪⻓⼭", "⻓跪"])   #冻结集合：把可变的集合变成了不可变得集合   不常用
dic = {s:'123'} # 可以正常使⽤了
print(dic)