python 字典操作提取key,value dictionaryName[key] = value
 
欢迎加入Python快速进阶QQ群：867300100
 
1.为字典增加一项
 
 2.访问字典中的值
 
 3、删除字典中的一项
 
 4、遍历字典
 
 5、字典遍历的key\value
 
 6、字典的标准操作符
 
 7、判断一个键是否在字典中
 
 8、python中其他的一些字典方法
 
 
 **9、将两个字典合并 **
 
a={'a':1,'b':2,'c':3}
b= {'aa':11,'bb':22,'cc':33}
#方法一
print(dict(a,**b))
#方法二 这其实就是在内存中创建两个列表，再创建第三个列表，拷贝完成后，创建新的dict，删除掉前三个列表。这个方法耗费性能，而且对于python3，这个无法成功执行，因为items()返回是个对象。
print(dict(list(a.items())+list(b.items())))
#方法三
c={}
c.update(a)
c.update(b)
print(c)
#方法四  python 3.5支持,可以存在重复键值，比如说：a={'a':1,'b':2,'c':3,'aa':12}会报错TypeError: print() got multiple values for keyword argument 'aa'
print(**a,**b)

他们的输出结果都是：
{'bb': 22, 'cc': 33, 'aa': 11, 'a': 1, 'b': 2, 'c': 3}
 
注意如果存在相同键值，比如说：
 a={'a':1,'b':2,'c':3,'aa':12}　b= {'aa':11,'bb':22,'cc':33}
 那么方法一＼二＼三得到结果为
 
{'cc': 33, 'a': 1, 'bb': 22, 'c': 3, 'b': 2, 'aa': 11｝
 
而方法四则会报错：
 
 
 
TypeError: print() got multiple values for keyword argument ‘aa’
 **10、key和value互换 **
 方法一：
 
 
#!/usr/bin/env python3
# -*- coding: utf-8 -*-

dict_ori = {'A':1, 'B':2, 'C':3}
dict_new = {value:key for key,value in dict_ori.items()}
print(dict_new)
 
{1: ‘A’, 2: ‘B’, 3: ‘C’}
 
方法二：
 使用zip方法
 
#!/usr/bin/env python3
# -*- coding: utf-8 -*-

dict_ori = {'A':1, 'B':2, 'C':3}
dict_new2= dict(zip(dict_ori.values(), dict_ori.keys()))
print(dict_new2)
 
{1: ‘A’, 2: ‘B’, 3: ‘C’}
 
**10、字典多键值及重复键值的使用方法(详解) **
 方案一
 
#encoding=utf-8
print ('中国')
#字典的一键多值
print('方案一 list作为dict的值 值允许重复'  )

d1={}
key=1
value=2
d1.setdefault(key,[]).append(value)
value=2
d1.setdefault(key,[]).append(value)
print (d1)
#获取值
print ('方案一 获取值')
print (list(d1[key])  )
print( '方案一 删除值，会留下一个空列表' )
d1[key].remove(value)
d1[key].remove(value)
print (d1  )
print ('方案一 检查是否还有一个值' )
print (d1.get(key,[]) )
 
方案一输出结果
 
中国
方案一 list作为dict的值 值允许重复
{1: [2, 2]}
方案一 获取值
[2, 2]
方案一 删除值，会留下一个空列表
{1: []}
方案一 检查是否还有一个值
[]
 
方案二
 
print ('方案二 使用子字典作为dict的值 值不允许重复')
d1={}
key=1
keyin=2
value=11
d1.setdefault(key,{})[keyin]=value
keyin=2
value=22
d1.setdefault(key,{})[keyin]=value
keyin=3
value=33
d1.setdefault(key,{})[keyin]=value
print (d1 )
print ('方案二 获取值' )
print (list(d1[key]) )
print ('方案二 删除值，会留下一个空列表' )
del d1[key][keyin]
keyin=2
del d1[key][keyin]
print (d1)
print ('方案二 检查是否还有一个值')
print (d1.get(key,()) )


 
方案二输出结果
 
方案二 使用子字典作为dict的值 值不允许重复
{1: {2: 22, 3: 33}}
方案二 获取值
[```2, 3]
方案二 删除值，会留下一个空列表
{1: {}}
方案二 检查是否还有一个值
{}
 
方案三
 
print ('方案三 使用set作为dict的值 值不允许重复')
d1={}

key=1
value=2
d1.setdefault(key,set()).add(value)
value=2
d1.setdefault(key,set()).add(value)
value=3
d1.setdefault(key,set()).add(value)
print ('方案三 获取值' )
print (list(d1[key]) )
print ('方案三 删除值，会留下一个空列表')
d1[key].remove(value)
value=2
d1[key].remove(value)
print (d1 )
print ('方案三 检查是否还有一个值' )
print (d1.get(key,()) )
 
输出结果：
 
方案三 使用set作为dict的值 值不允许重复
{1: {2, 3}}
方案三 获取值
[2, 3]
方案三 删除值，会留下一个空列表
{1: set()}
方案三 检查是否还有一个值
set()
 
相关应用直通车：
 自然语言处理：直通车
 Nosql-mongodb:直通车

手动推荐知识点
 
字典创建-> 创建字典（7种方式）
 
删除元素-> 字典删除元素（6种方式）
 
修改元素-> 字典修改元素（4种方式）
 
遍历元素-> 字典遍历元素（4种方式）
 
查找元素-> 字典查找元素（3种方式）
 
 
 
本文使用代码
 
book_dict = {"price": 500, "bookName": "Python设计", "weight": "250g"}
 
第一种方式：使用[]
 
book_dict["owner"] = "tyson" 
 
说明：中括号指定key，赋值一个value，key不存在，则是添加元素（如果key已存在，则是修改key对应的value）
 
 
 
第二种方式：使用update（）方法，参数为字典对象
 
book_dict.update({"country": "china"}) 
 
说明：使用dict的update（）方法,为其传入一个新的dict对象，key不存在则是添加元素！（如果这个新的dict对象中的key已经在当前的字典对象中存在了，则会覆盖掉key对应的value）
 
 
 
第三种方式：使用update（）方法，参数为关键字参数
 
book_dict.update(temp = "无语中", help = "帮助") 
 
说明：同样使用dict的update方法，但传入的是关键字参数，key不存在则是添加元素（key存在则是修改value）
 
注意：关键字参数形式，key对象只能是字符串对象
 
 
 
第四种方式：使用update（）方法，参数为字典解包方式
 
my_temp_dict = {"name": "王员外", "age":18}
book_dict.update(**my_temp_dict) 
 
等同于
 
book_dict.update(name="王员外",age=18) 
 
 
 
注意：字典是完全无序的映射集合
 
1、字典无序：当你遍历字典元素时，与你添加元素的顺序、与你访问元素的顺序均无任何关联！
 
2、当你遍历一个字典对象时，如果与你添加元素的顺序是一样的，这仅仅是个巧合而已，需要元素有序的字典请看OrderedDict
 
 

 
 
 
文章目录
 
 

  
一、前言
  
二、字典树的原理与实现
  

   

    
1、字典树简介
    
2、字典树原理
    

     

      
1）字典树结构
      
2）字符串插入
      
3）字符串查询
     
 
    
3、字典树实现
    

     

      
1）类结构设计
      
2）接口设计
     
 
   
 
  
三、字典树的应用与扩展
  

   

    
1、前缀查询
    
2、最短前缀表示
    
3、删除字符串
    
4、删除前缀
    
5、集合前缀
    
6、离线算法
    
7、模糊匹配
    
8、集合最大异或
    
9、树的异或最长路
   
 
  
四、字典树题集整理
 
 
 
 
一、前言
 

  <

 
 
数据字典
 
 
数据字典是一种通用的程序设计方法。可以认为，不论什么程序，都是为了处理一定的主体，这里的主体可能是人员、商品（超子）、网页、接口、数据库表、甚至需求分析等等。当主体有很多的属性，每种属性有很多的取值，而且属性的数量和属性取值的数量是不断变化的，特别是当这些数量的变化很快时，就应该考虑引入数据字典的设计方法。
 
 
 
数据字典有两种形式
 
 
一、把主体的属性代码化放入独立的表中，不是和主体放在一起，主体中只保留属性的代码。这里属性的数量是不变的，而属性取值的数量可以是变化的。
 
二、用一个表来放结构相同的所有属性信息，不同属性的不同取值统一编码，用“类型”来区别不同的属性，主体中保留属性代码的列表。这样主体所拥有的属性数量就是可变的了。
 
第二种数据字典比第一种更抽象，层级更高，也更具一般性、通用性。
 
这两种形式的归纳有些抽象，为说明这两种数据字典和它们的各种优点，下面举个简单的例子来说明：
 
现在有个需求，要在程序中处理“职员”信息。这里的主体就是“职员”，开始时“职员”有“国籍”、“证件”和“学历”等属性。
 
比如，对于一个“职员信息”页面上的“国籍”下拉列表，我们可以就用第一种的数据字典来存储不同的国家。如果不采取这样的方法，就需要手动的把所有可能的国家名称敲到页面上。这首先有个效率的问题，每个需要用到国籍的地方都要敲一次，要敲多久？还有，如果有一天，像南斯拉夫，突然国家换名了，是不是要所有涉及的页面都要手动地改变呢？
 
又比如，如果有一天一个代码的名称需要换一个，是不是要到数据库中把已经经存在的所有数据都更新一遍呢？如“证件”，现在叫“身份证”，有一天想改为叫“居民身份证”。原来如果没有用数据字典，就意味着，要把“身份证”这几个字存到《职员表》等信息表中：
 
 
 
《职员表》
 
 
姓名　　证件　　性别
 
 
张三　　身份证　男
 
 
李四        身份证   女
 
 
....
 
 
这样，改名后就要手动改数据库。但如果使用了数据字典，《职员表》里面存的就是：
 
 
 
《职员表》
 
 
姓名　　证件　　性别
 
 
张三　　001           男
 
 
李四       001           女
 
 
....
 
 
另外增加了《证件表》：
 
 
 
《证件表》
 
 
证件id  证件名
 
 
001      身份证
 
 
002      暂住证
 
 
...
 
 
《证件表》就是第一种数据字典。要改变证件名称时，只要把其中的“身份证”改成“居民身份证”就好了，只需修改一次。而且，《职员表》不用做任何修改，页面上如果用到“证件”，也不用做修改。
 
还有在程序中有时需要判断业务逻辑时，用：“select *  from 职员表 where证件= ***”，原来***是“身份证”，使用数据字典后，就是001。证件改名后，就不用手动到程序里去改，程序也就不用重新测试、发布等等。
 
但第一种数据字典也有局限性。
 
使用第一种数据字典后，程序中除“职员”类外，还就需要有一个“国籍”类、一个“证件”类和一个“学历”类，对应的数据库中也需要增加一张“国籍”表、一张“证件”表和一张“学历”表。“职员”类则需要包含一个对“国籍”类的引用、一个对“证件”类的引用和一个对“学历”类的引用，对应的数据库中“职员”表中也需要三个外键分别指向“国籍”表、“证件”表和“学历”表。这样的设计在类似“国籍”和“学历”这样的属性比较少时是可行的，但是随着系统复杂性的增加，系统中会出现大量结构类似的信息表和信息类，数量一直会增加到一个不可接受的地步。这里的“职员”，已经有了国籍、证件和学历三个属性，但如果职员还要增加“职位”属性，那么必然要多出个“职位表”，如果还有其它...那即，当取得一条主体的完全数据时，那将进行几十个表的联接（join）操作。
 
如何解决呢？
 
通过分析上述问题，可以发现的一个特征是：这些信息类的内容都是需要动态维护的，但是所需的属性是一样的，对应的数据库表中包含的字段也是一样的。关键的字段就是两个：“标识”和“名称”。“标识”用于表示不变的主键，“名称”用于表示程序界面上显示的文字。
 
第二种数据字典就是为了解决上述问题而设计的。
 
还是以上面的例子为例。在系统中去掉《国籍表》、《证件表》、《学历表》….，引入《系统代码分类表》和《系统代码表》:
 
 
 
《系统代码分类表》
 
 
分类标识           分类名称
 
 
Country              国籍
 
 
ID                       证件
 
 
…
 
 
 
 
《系统代码表》
 
 
标识                   分类                  内容
 
 
001                    Contry              中国
 
 
002                    Contry              美国
 
 
…..
 
 
501                    ID                    身份证
 
 
502                    ID                    暂住证
 
 
……
 
 
《系统代码表》的“分类”字段都指向《系统代码分类表》中的“分类标识”。这样，在程序需要获得国籍信息时，只要通过“Country”这个标识去《系统代码表》中检索就可以了。这样的设计也便于建立一个单独的程序模块来维护所有的这些公共信息。
 
对于《职员表》，使用第一种数据字典时，其表结构是：
 
职员ID、姓名、国籍ID、证件ID、学历ID…….
 
 
 
采用第二种数据字典后，其表结构是：
 
职员ID、姓名
 
另外增加《属性表》，该表是《职员表》和《系统代码表》的关系表，其表结构是：
 
属性ID、职员ID、系统代码表_标识
 
如：
 
 
 
《职员表》
 
 
职员ID            姓名
 
 
1                     张三
 
 
2                     李四
 
 
…..
 
 
 
 
《属性表》
 
 
属性ID            职员ID                系统代码表_标识
 
 
1                         1                         001  （表示张三是中国籍）
 
 
2                         1                         501  （表示张三的证件是身份证）
 
 
3                         2                         002  （表示李四是美国籍）
 
 
4                         2                         501  （表示李四的证件是身份证）
 
 
…..
 
 
可以看出《职员表》的设计大为简化，系统也更加灵活了，完全可以适应主体属性的大量变更了。程序的设计应用第二种数据字典时和数据库表的方法一样。
 
 
 
数据字典的优点
 
 
在一定程度上，通过系统维护人员即可改变系统的行为（功能），不需要开发人员的介入。使得系统的变化更快，能及时响应客户和市场的需求。
提高了系统的灵活性、通用性，减少了主体和属性的耦合度
简化了主体类的业务逻辑
能减少对系统程序的改动，使数据库、程序和页面更稳定。特别是数据量大的时候，能大幅减少开发工作量
使数据库表结构和程序结构条理上更清楚，更容易理解，在可开发性、可扩展性、可维护性、系统强壮性上都有优势。
 
 
数据字典的缺点
 
 
数据字典是通用的设计，在系统效率上会低一些。
程序算法相对复杂一些。
对于开发人员，需要具备一定抽象思维能力，所以对开发人员的要求较高。
所以，当属性的数量不多时，用第一种数据字典即可。对于大型的，未定型的系统，可以采用第二种数据字典来设计。至于具体的系统里怎么设计，还是要在看实际情况来找寻通用性和效率二者间的平衡。无论怎么做，关系理论和范式仍是基础。
 
 
 
数据字典的一般设计
 
 
下面给出一个用数据库实现的第二种数据字典表的设计。要注意这个设计不是唯一的，完全可以用XML、字符串等形式来设计数据字典。
 
数据字典表(Dictionary)：
 
 
字段名
 
 
类型
 
 
说明
 
 
编号
 
 
Char(16)
 
 
间断增量(Not Null,PK)
 
 
分类名称
 
 
Varchar(64)
 
 
用来进行过滤选取字典表相关域
 
 
内容
 
 
Varchar(255)
 
 
   
 
 
父级编号
 
 
Char(16)
 
 
取Dictionary的编号(FK)，用来进行等级设计。使之成为树型结构。