5Python全栈之路系列之字典数据类型

字典(dict)在基本的数据类型中使用频率也是相当高的，而且它的访问方式是通过键来获取到对应的值，当然存储的方式也是键值对了，属于可变类型。

字典：存储数据多，关系型数据，查询速度快（二分查找）

---

创建字典的两种方式

第一种

>>> dic = {"k1":"123","k2":"456"}
>>> dic
{'k1': '123', 'k2': '456'}
>>> type(dic)
<class 'dict'>

第二种

>>> dic = dict({"k1":"123","k2":"456"})
>>> dic
{'k1': '123', 'k2': '456'}
>>> type(dic)
<class 'dict'>

在创建字典的时候，__init__初始化的时候还可以接受一个可迭代的变量作为值

>>> li = ["a","b","c"]
>>> dic = dict(enumerate(li))
>>> dic
{0: 'a', 1: 'b', 2: 'c'}

默认dict再添加元素的时候会把li列表中的元素for循环一边，添加的时候列表中的内容是字典的值，而键默认是没有的，可以通过enumerate方法给他加一个序列，也就是键。

与其变量不同的是，字典的键不仅仅支持字符串，而且还支持其他数据类型，譬如：

# 数字
>>> D = {1:3}
>>> D[1]
3
# 元组
>>> D = {(1,2,3):3}
>>> D[(1,2,3)]
3

字典解析

>>> D = {x: x*2 for x in range(10)}
>>> D
{0: 0, 1: 2, 2: 4, 3: 6, 4: 8, 5: 10, 6: 12, 7: 14, 8: 16, 9: 18}
# 可以使用zip
>>> D = {k:v for (k, v) in zip(['a','b','c'],[1,2,3])}
>>> D
{'a': 1, 'c': 3, 'b': 2}

#zip 小例子

li = ["a","b"]
dic = {"1":[],"2":[]}
for k,v in zip(dic,li):
    print(k,v)

a 1
b 2

 

字典所提供的常用方法

增：

dic = {'name':'taibai','age':21,'hobby':'girl',}

dic['hight'] = 180     #有则覆盖，无则添加

print(dic)

{'name': 'taibai', 'age': 21, 'hobby': 'girl', 'hight': 180}

 

setdefault(self, k, d=None):         如果key不存在，则创建，如果存在，则返回已存在的值且不修改

属性	描述
key	查找的键值
default	键不存在时，设置的默认键值

>>> person = {"name": "ansheng", 'age': 18}
# 如果字典中有这个键，那么就输出这个键的值
>>> person.setdefault("name")
'ansheng'
# 如果没有则不输出，但是会创建一个键，值为默认的'None'，值是可以指定的
>>> person.setdefault("sex")
>>> person
{'age': 18, 'name': 'ansheng', 'sex': None}

>>>person.setdefault("hobby",'打豆豆')         #也可以指定默认值
>>>person
{'name': 'ansheng', 'age': 18, 'hobby': '打豆豆'

 

删：

pop(self, k, d=None):      删除指定给定键所对应的值，返回这个值并从字典中把它移除

 

>>> person = {"name": "ansheng", 'age': 18}
>>> person
{'age': 18, 'name': 'ansheng'}
# 返回删除键对应的值
>>> person.pop("age")
18
>>> person
{'name': 'ansheng'}

 

clear(self):       删除字典中的所有元素

>>> person = dict({"name": "ansheng", 'age': 18})
>>> person
{'age': 18, 'name': 'ansheng'}
>>> person.clear()
# 清空字典的内容之后字典会变成一个空字典
>>> person
{}

 

popitem(self):        随机返回并删除字典中的一对键和值，因为字典是无序的，没有所谓的”最后一项”或是其它顺序。

>>> person = {"name": "ansheng", 'age': 18}
# 随即删除并显示所删除的键和值
>>> person.popitem()
('age', 18)
>>> person
{'name': 'ansheng'}

 

改：

 

dic = {'name':'taibai','age':21,'hobby':'girl',}
dic['name'] = '老男孩'

print(dic)

{'name': '老男孩', 'age': 21, 'hobby': 'girl'}

 

update(self, E=None, **F):           把字典dic2的键/值对更新到dic1里

>>> dic1 = {"name":"zhishu"}
>>> dic2 = {"age":"18"}
>>> dic1
{'name': ''zhishu}
>>> dic2
{'age': '18'}
>>> dic1.update(dic2)
>>> dic1
{'age': '18', 'name': 'zhishu'}

 

查：

直接print查

dic = {'name':'taibai','age':21,'hobby':'girl',}

print(dic['name'])

get(self, k, d=None):                 返回指定键的值，如果值不在字典中返回默认值

属性	描述
key	字典中要查找的键
default	如果指定键的值不存在时，返回该默认值值

>>> person = {"name": "ansheng", 'age': 18}
>>> person.get("name")
'ansheng'

 

keys(self):        以列表的形式返回一个字典所有的键

>>> person = {"name": "ansheng", 'age': 18}
>>> person.keys()
['age', 'name']

#以列表展示
dic = {'name':'taibai','age':21,'hobby':'girl',}
for i,val in enumerate (dic.keys(),1):
    print(i,val)

1 name
2 age
3 hobby

 

values(self):          显示字典中所有的值

>>> person = {"name": "ansheng", 'age': 18}
>>> person.values()
[18, 'ansheng']

 

items(self):             以列表返回可遍历的(键, 值)元组数组

>>> person = {"name": "mr.wu", 'age': 18}
# 以元组的方式输出出来
>>> person.items()
[('age', 18), ('name', 'mr.wu')]

 

copy(self):        返回一个字典的浅复制

>>> person = dict({"name": "ansheng", 'age': 18})
>>> person.copy()
{'age': 18, 'name': 'ansheng'}

 

fromkeys(S, v=None):        创建一个新字典，以序列seq中元素做字典的键，value为字典所有键对应的初始值

属性	描述
S	字典键值列表
v	可选参数, 设置键序列（seq）的值

>>> seq = ('name', 'age', 'sex')
>>> dict = dict.fromkeys(seq)
>>> dict
{'age': None, 'name': None, 'sex': None}

fromkeys方法就是把一个字典的key更新到另外一个字典中，默认的值可以设置

>>> dic={"k1":123,"k2":456,"k4":111}
>>> dic
{'k1': 123, 'k4': 111, 'k2': 456}
# 创建一个新的字典，默认值是`123`
>>> dic.fromkeys(["k1","k2","k3"],"123")
{'k1': '123', 'k3': '123', 'k2': '123'}

 

成员运算符in可以判断键是否存在于字典中，如果键在字典dict里返回true，否则返回false

>>> person = {"name": "mr", 'age': 18}
>>> 'name' in person
True
>>> 'aname' in person
False

 

 

分别赋值运算：

a,b,c = ['alex','wusir','taibai']
print(a,b,c)

alex wusir taibai

a = 1
b = 5
a,b = b,a
print(a,b)

5 1

dic = {"name":"jin","age":18,"sex":"male"}
for i in dic.items():         #返回元祖单独传值
    print(i)

('name', 'jin')
('age', 18)
('sex', 'male')

for k,v in dic.items():
    print(k,v)                #单个传值

name jin
age 18
sex male

 

dic = {"name":"jin","age":18,"sex":"male"}
print(len(dic))  #显示长度

3

 

字典嵌套：

dic = {
    'name_list':['b哥','张帝','人帅','kitty'],
    '老男孩':{
     'name':'老男孩',
     'age':'46',
     'sex':'ladyboy',
    }
}
#1，name_list 追加一个元素 '骑兵'
#2，将kitty全部大写。
#3，将老男孩改为oldboy
#4，将ladyboy首字母大写
dic['name_list'].append('骑兵')
#print(dic['name_list'])   #不输出，检查一改完第一个要求得到的结果然后，再做下一个要求

dic['name_list'][-2] = dic['name_list'][-2].upper()

dic['老男孩']['name'] = 'oldboy'
dic['老男孩']['sex']=dic['老男孩']['sex'].capitalize()

print(dic)

 

dict = {}
dict['list']=[]

dict['list'].append([1,2,3,4])
dict['list'].append([5,6,7])


print(dict)
print(dict["list"])

#结果
{'list': [[1, 2, 3, 4], [5, 6, 7]]}
[[1, 2, 3, 4], [5, 6, 7]]

 

sentence = 'hello world nihao world hey hello java world hi python yeoman word'

#先把字符串分割成单个单词列表
list1 = sentence.split() 
#['hello', 'world', 'nihao', 'world', 'hey', 'hello', 'java', 'world', 'hi', 'python', 'yeoman', 'word']
print list1 

#把列表转为结合，为了去除重复的项
set1 = set(list1)   
#set(['java', 'python', 'word', 'nihao', 'hey', 'yeoman', 'hi', 'world', 'hello'])
print set1  

#把集合转为列表，集合元素没有顺序，没有索引属性，而列表有
list2 = list(set1)  
#['java', 'python', 'word', 'nihao', 'hey', 'yeoman', 'hi', 'world', 'hello']
print list2 

#新建一个空的字典
dir1 = {}

for x in range(len(list2)): 
    dir1[list2[x]] = 0  #字典值初始为0
    for y in range(len(list1)):
        if list2[x] == list1[y]:
            dir1[list2[x]] += 1

#{'word': 1, 'python': 1, 'nihao': 1, 'hey': 1, 'hello': 2, 'hi': 1, 'world': 3, 'java': 1, 'yeoman': 1}
print dir1 

str1 = "hello world god is allways busy"

dir1 = {}
for x in range(len(str1)):
    dir1[str1[x]] = 0  #字典值初始为0
    for y in range(len(str1)):
        if str1[x] == str1[y]:
            dir1[str1[x]] += 1

print(dir1)



{'h': 1, 'e': 1, 'l': 5, 'o': 3, ' ': 5, 'w': 2, 'r': 1, 'd': 2, 'g': 1, 'i': 1, 's': 3, 'a': 2, 'y': 2, 'b': 1, 'u': 1}

#10.组合嵌套题，写代码，有如下列表，按照要求实现每一个功能
lis = [['k',['qwe',20,{'k1':['tt',3,'1']},89],'ab']]
#1.将列表lis 中的'tt'变成大写（用两种方式）
#1
print(lis[0][1][2].get('k1')[0].upper())
#2
print(lis[0][1][2].get('k1')[0].swapcase())

#2.将列表中的数字3 变成字符串'100'(用两种方式）
#1
print(lis)
lis[0][1][2].get('k1')[1] = '100'
print(lis)
#2
lis = [['k',['qwe',20,{'k1':['tt',3,'1']},89],'ab']]
dic3 = {'k1':['tt','100','1']}
print(lis)
lis[0][1][2].update(dic3)
print(lis)

#3 将列表中的字符串'1'变成数字101（用两种方式）
#1
lis = [['k',['qwe',20,{'k1':['tt',3,'1']},89],'ab']]
print(lis)
lis[0][1][2].get('k1')[2] = 101
print(lis)
#2
lis = [['k',['qwe',20,{'k1':['tt',3,'1']},89],'ab']]
dic3 = {'k1':['tt',3,101]}

lis[0][1][2].update(dic3)
print(lis)