字典_字典树 - CSDN
字典 订阅
字典(拼音: zì diǎn;英文:dictionary,character dictionary)是为字词提供音韵、意思解释、例句、用法等等的工具书。在西方,没有字典的概念,全是中国独有的。 字典收字为主,也会收词。 [1]  词典或辞典收词为主,也会收字。为了配合社会发展需求,词典收词数量激增并发展出不同对象、不同行业及不同用途的词典。随著吸收百科全书的元素,更有百科辞典,现在收录汉字最多的是《中华大字典》。 展开全文
字典(拼音: zì diǎn;英文:dictionary,character dictionary)是为字词提供音韵、意思解释、例句、用法等等的工具书。在西方,没有字典的概念,全是中国独有的。 字典收字为主,也会收词。 [1]  词典或辞典收词为主,也会收字。为了配合社会发展需求,词典收词数量激增并发展出不同对象、不同行业及不同用途的词典。随著吸收百科全书的元素,更有百科辞典,现在收录汉字最多的是《中华大字典》。
信息
类    型
工具书类
拼    音
zì diǎn
分    类
书籍
中文名
字典
外文名
dictionary
字典简介
字典属工具书类。第一部字典性质的《尔雅》的这个名称它很明显就明确了字典的功能。“尔”也写作“迩”是接近的意思,“雅”是“正”的意思,指“雅言”,即在语音、词汇和语法等方面都合乎规范的标准语。《尔雅》的意思是接近、符合雅言,就是以雅正之言解释语词和方言,使之接近规范。中国古代字典都称为“字书”,直到《康熙字典》问世才称“字典”的。最早的一本汉语词典是《尔雅》成书的上限不早于战国,因为书中所用的资料,有的来自《楚辞》、《庄子》、《吕氏春秋》等书,而这些书是战国时代的作品;成书的下限不会晚于西汉初年,因为在汉文帝时已经设置了《尔雅》博士,到汉武帝时已经出现了犍为文学的《尔雅注》。近代大致可分为两类,一类是综合性的,如《新华字典》;一类是专门性的,如《异体字字典》。
收起全文
精华内容
参与话题
  • 字典{}

    千次阅读 2019-09-21 09:29:46
    1. 字典 dict 用{}来表示 键值对数据 {key:value} 唯一性 键 都必须是可哈希的 不可变的数据类型就可以当做字典中的键 值 没有任何限制 2. 增删改查 字典的增加: dic[key] = value #强制增加 dic = {...


    1. 字典

    dict 用{}来表示 键值对数据 {key:value} 唯一性

    键 都必须是可哈希的 不可变的数据类型就可以当做字典中的键

    值 没有任何限制

    2. 增删改查

    字典的增加:

    dic[key] = value           #强制增加

    dic = {'num': '1', 'sum': '2'}
    dic['key_1'] = 'value_1'
    print(dic)
    输出:{'num': '1', 'sum': '2', 'key_1': 'value_1'}

    dic.setdefault(key,value)             #如果键在字典中存在不进行任何操作,否则就添加

    dic = {'num': '1', 'sum': '2'}
    dic.setdefault('key_2', 'value_2')
    print(dic)
    输出:{'num': '1', 'sum': '2', 'key_2': 'value_2'}

    字典的删除:

    dic.pop(key)           # 有返回值 返回的是被删除value

    dic = {'num': '1', 'sum': '2', 'key_2': 'value_2'}
    i = dic.pop('sum')
    print(dic)
    print(i)
    输出:{'num': '1', 'key_2': 'value_2'}
       2

    del dic[key]            #通过键删除对应的值

    dic = {'num': '1', 'sum': '2', 'key_2': 'value_2'}
    del dic['num']
    print(dic)
    输出:{'sum': '2', 'key_2': 'value_2'}

    dic.popitem()            #随机删除;python3.6以上默认删除最后一位

    dic = {'num': '1', 'sum': '2', 'key_2': 'value_2'}
    dic.popitem()
    print(dic)
    输出:{'num': '1', 'sum': '2'}

    dic.clear()              #清空字典

    dic = {'num': '1', 'sum': '2', 'key_2': 'value_2'}
    dic.clear()
    print(dic)
    输出:{}

    字典的修改:

    dic[key] = value          #通过键修改对应的值

    dic = {'num': '1', 'sum': '2', 'key_2': 'value_2'}
    dic['num'] = '2'
    print(dic)
    输出:{'num': '2', 'sum': '2', 'key_2': 'value_2'}

    dic.update(字典)           #通过字典更新dic

    dic = {'num': '1', 'sum': '2', 'key_2': 'value_2'}
    dic_1 = {'num': '2', '亚索': '托儿索'}
    dic.update(dic_1)
    print(dic)
    输出:{'num': '2', 'sum': '2', 'key_2': 'value_2', '亚索': '托儿索'} #dic的'num'的值被dic_1更新并更新dic没有的键值对

    字典的查询:

    dic.get(key,提示信息)      #通过字典的键查询对应的值,如果没有找到,返回提示信息,默认返回None

    dic = {'num': '1', 'sum': '2', 'key_2': 'value_2'}
    print(dic.get('num', '没有对应的输入'))
    输出:1
    dic = {'num': '1', 'sum': '2', 'key_2': 'value_2'}
    print(dic.get('nm', '没有对应的输入'))
    输出:没有对应的输入

    dic[key]               #通过字典的键查询对应的值,如果没有找到,报错

    dic = {'num': '1', 'sum': '2', 'key_2': 'value_2'}
    print(dic['num'])
    输出:1
    dic = {'num': '1', 'sum': '2', 'key_2': 'value_2'}
    print(dic['nm'])
    输出:

    Traceback (most recent call last):
    File "C:/Users/PycharmProjects/测试.py", line 27, in <module>
    print(dic['nm'])
    KeyError: 'nm'

    for 循环               #默认获取字典的键

    #第一种  循环输出所有的key
    dic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}
    for key in dic:
    print(key) 
    输出:k1,k2,k3
    # 方法二   循环输出所有的key
    dic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}
    for key in dic.keys():
        print(key)  
    输出:k1,k2,k3
    #  循环输出所有的value
    for key in dic.values():
    print(key) # v1,v2,[11,22,33]
    输出:v1,v2,[11,22,33]

      

    # 方法一   循环输出所有的key和value
    dic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}
    for key in dic.items():
    print(key) # ('k1', 'v1'),('k2', 'v2'),('k3', [11, 22, 33])
    输出:('k1', 'v1'),('k2', 'v2'),('k3', [11, 22, 33])
    # 方法二  循环输出所有的key和value
    dic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}
    for key,value in dic.items():
         print(key,value)  
    输出:# 'k1' "v1", "k2" "v2", "k3" [11,22,33]

    dic.setdefault(key,提示信息)    #通过字典的键查询对应的值,如果没有找到,返回提示信息,默认返回None

    dic = {'num': '1', 'sum': '2', 'key_2': 'value_2'}
    print(dic.setdefault('num', '没有对应的输入'))
    输出:1
    dic = {'num': '1', 'sum': '2', 'key_2': 'value_2'}
    print(dic.setdefault('nm', '没有对应的输入'))
    输出:
    没有对应的输入

    3.字典的其他操作:

    dic.keys()             # 获取到所有的键存在一个高仿的列表中

    dic = {'num': '1', 'sum': '2', 'key_2': 'value_2'}
    print(dic.keys())
    输出:dict_keys(['num', 'sum', 'key_2'])

    dic.values()            #获取到所有的值存在一个高仿的列表中

    dic = {'num': '1', 'sum': '2', 'key_2': 'value_2'}
    print(dic.values())
    输出:dict_values(['1', '2', 'value_2'])

    dic.items()           #获取到所有的键值对已元祖的形式存在一个高仿的列表中

    dic = {'num': '1', 'sum': '2', 'key_2': 'value_2'}
    print(dic.items())
    输出:dict_items([('num', '1'), ('sum', '2'), ('key_2', 'value_2')])

    解构:

    a,b = 1, 2               #输出a = 1,b = 2

    a,b = (1,2)              #输出a = 1,b = 2

    a,b = [1,2]              #输出a = 1,b = 2

    4. 字典的嵌套:

    dic = {
    'name':'熊父',
    'age':43,
    'wife':{
    'name':'熊母',
    'age':39,
    'salary':100000
    },
    'baby':[
    {'name':'熊大','age':18},
    {'name':'熊二','age':15},
    ]

    }

    dic['baby'][0]['age'] = 19

    print(dic)

    转载于:https://www.cnblogs.com/Virous1887/p/9403823.html

    展开全文
  • python字典用法大全

    千次阅读 多人点赞 2018-10-27 23:50:58
    目录 序言: 1.0 dict()函数 2.0 clear()函数 3.0 copy()函数 4.0 fromkeys()函数 5.0 get()函数 6.0 items()函数 7.0 keys()函数 8.0 values()函数 9.0 pop()函数 10.0 popitem()函数 ......

    目录

    序言:

    1.0 dict()函数

    2.0 clear()函数

    3.0 copy()函数

    4.0 fromkeys()函数

    5.0 get()函数

    6.0 items()函数

    7.0 keys()函数

    8.0 values()函数

    9.0 pop()函数

    10.0 popitem()函数

    11.0 setdefault()函数

    12.0 update()函数


     

    序言:

    字典是映射类型的典型代表,字典是 键-值 元素项的组合,每一个元素是一个键值对,表示为(key,value)。字典与集合具有类似的性质,即字典中的键值对之间是无序的,并且不能重复,也没有下标索引。

    python中字典用大括号 { } 表示,表示方式如下:

    {<键1>:<值1>,<键2>:<值2>,<键3>:<值3>,...,<键n>:<值n>}

    1.0 dict()函数

    描述:生成一个字典。

    语法:

    ① dict() -> 生成一个空字典。

    程序示例:

    d = dict() #创建空字典
    dt = {} #创建的是空字典,不是空集合
    print(d,dt,type(d),type(dt))

     程序运行结果:

    {} {} <class 'dict'> <class 'dict'>

    ② dict(mapping) -> 从映射对象(键,值)对新字典进行初始化。 

    程序示例:

    d1 = dict(zip([1,2,3],["a","b","c"]))  #具有明显的映射关系
    d2 = dict(zip(("a","b","c"),(1,2,3,5))) #第二个元组多个5,不影响映射。
    d3 = dict({1:"a",2:"b",5:"c"})
    print(d1,d2,d3)

    程序运行结果:

    {1: 'a', 2: 'b', 3: 'c'} {'a': 1, 'b': 2, 'c': 3} {1: 'a', 2: 'b', 5: 'c'}
    In [ ]:
    

    ③ dict(iterable) -> 通过iterable(可迭代对象)对新字典进行初始化。

    等效于以下代码:

    d = {}
    for k, v in iterable:
        d[k] = v

    程序示例:

    d1 = dict([("a",66),(2,5)]) #可迭代的对象的元素只能是值,不能是未定义的变量。
    print(d1)
    
    #d1 等效于:
    """d = {}
    iterable = [("a",66),(2,5)]
    for k, v in iterable:
        d[k] = v"""
    
    d2 = dict([(1,c),(2,"a")]) #程序报错,c可做变量,但未定义。
    print(d2)

    程序运行结果:

    {'a': 66, 2: 5}
    ---------------------------------------------------------------------------
    NameError                                 Traceback (most recent call last)
    <ipython-input-50-b6cfcff029fa> in <module>()
          8     d[k] = v"""
          9 
    ---> 10 d2 = dict([(1,c),(2,"a")]) #程序报错,b可做变量,但未定义。
         11 print(d2)
    
    NameError: name 'c' is not defined

    ④ dict(**kwargs) ->在关键字参数列表中使用name = value对新字典进行初始化。

    例如:dict(one=1, two=2)  注:关键字参数的等号左边必须为一个变量,且右边必须为一个值,不可为变量,否则会报错。

    程序示例:

    d1 = dict(one=1,two=2,three=3)
    print(d1)
    
    """d2 = dict(1="a",2="b") #程序报错,1,2不是变量
    print(d2)"""

    程序运行结果:

    {'two': 2, 'one': 1, 'three': 3}
    
    """ File "<ipython-input-65-aa17f57e0b8d>", line 1
        d2 = dict(1="a",2="b") #程序报错,1,2不是变量
                 ^
    SyntaxError: keyword can't be an expression"""
    • mapping ——元素的容器。
    • iterable ——可迭代对象
    • **kwargs ——关键字

    2.0 clear()函数

    描述:删除字典d中所有的键值对。

    语法: d.clear() -> None 返回一个空字典

    程序示例:

    d = {"one":1,"two":2,"three":3}
    print("清空前:",d)
    d.clear() #清空字典d所有键值对
    print("清空后:",d)

    程序运行结果:

    清空前: {'two': 2, 'one': 1, 'three': 3}
    清空后: {}

    3.0 copy()函数

    描述生成一个新字典,浅复制字典d中的所有键值对。即父对象不变,但子对象改变。

    语法: d.copy() ->返回字典d的浅拷贝

    程序示例:

    import copy
    
    d1 = {"小明":98,"小红":99,"小东":[33,56,65]}
    print("原始数据:",d1)
    
    d2 = d1 # 引用拷贝 d1和d2指向同一个内存地址,d2只是d1的一个别名。
    d3 = d1.copy() #浅拷贝,d3和d2的父对象相互独立,但子对象[33,56,65]指向同一个内存地址。
    d4 = copy.copy(d1) #深拷贝,父对象,子对象都相互对立。
    
    d1["小明"] = 86 #将字典d1中父对象"小明"的分数修改为 86
    d2["小东"].append(95)  #向字典d1中子对象列表[33,56,65]添加一个元素 95
    
    print("修改后的数据:",d1) 
    print("引用拷贝:",d2) #引用拷贝,父对象,子对象都改变
    print("浅拷贝:",d3) #浅拷贝,父对象不改变,但子对象改变
    print("深拷贝:",d4) #深拷贝,父对象,子对象都不改变。

    程序运行结果:

    原始数据: {'小明': 98, '小红': 99, '小东': [33, 56, 65]}
    修改后的数据: {'小明': 86, '小红': 99, '小东': [33, 56, 65, 95]}
    引用拷贝: {'小明': 86, '小红': 99, '小东': [33, 56, 65, 95]}
    浅拷贝: {'小明': 98, '小红': 99, '小东': [33, 56, 65, 95]}
    深拷贝: {'小明': 98, '小红': 99, '小东': [33, 56, 65, 95]}

    总结:(原始字典d1,浅拷贝字典d2, 深拷贝字典d3)   

    对于浅拷贝 —— 无论是改变 原始字典d1 的子对象,还是改变浅拷贝字典d2 的子对象,字典d1,字典d2的子对象都会改变。但父对象互不影响。

    对于深拷贝——整个字典独立,互不影响。

    4.0 fromkeys()函数

    描述:创建一个新字典,以可迭代对象iterable中元素做字典的键,value 为字典所有键对应的初始值,默认值为None。

    语法:fromkeys(iterable, value=None, /)

    • iterable —— 可迭代的对象。如 列表,元组,集合,字典,字符串等
    • value —— 可迭代的对象或数字,字母。如 列表,元组,集合,字典,字符串等可迭代对象

    程序示例:

    d1 = {}
    d2 = {}
    d3 = {}
    d4 = {}
    
    print(d1.fromkeys("123")) # iterable为字符串,value为默认值None
    print(d2.fromkeys([1,2,"a"],["a",1])) #iterable为列表,value为列表
    print(d3.fromkeys({1,"b",2},(1,2))) #iterable为集合,value为元组
    print(d4.fromkeys({"a":1,"b":2},1)) #iterable为字典,value为数字 1
    

    程序运行结果:

    {'2': None, '3': None, '1': None}
    {'a': ['a', 1], 1: ['a', 1], 2: ['a', 1]}
    {1: (1, 2), 2: (1, 2), 'b': (1, 2)}
    {'a': 1, 'b': 1}

    5.0 get()函数

    描述:返回d[k],若字典d中无k键,则返回d

    语法: d.get(k,d) -> D[k] if k in D, else d. d 默认值为 None.

    • k —— 键
    • d —— 若k不在字典d中,则返回自定义的d,d默认值为None.

    程序示例:

    d = {"one":1,"two":2,"three":3}
    print(d.get("one",666)) #键"one"存在,返回d["one"],不返回d值 666
    print(d.get("five",666)) #键"five"不存在,返回d值 666
    print(d.get("five")) #键"five"不存在,返回d的默认值 None
    

    程序运行结果:

    1
    666
    None

    6.0 items()函数

    描述:返回字典d中所有键值对

    语法: d.items() 

    程序示例:

    d = {"one":1,"two":2,"three":3}
    print(d.items(),type(d.items()))

    程序运行结果:

    dict_items([('two', 2), ('one', 1), ('three', 3)]) <class 'dict_items'>

    7.0 keys()函数

    描述:返回字典d中所有键的信息。

    语法:d.keys()

    程序示例:

    d = {"one":1,"two":2,"three":3}
    print(d.keys(),type(d.keys()))

    程序运行结果:

    dict_keys(['two', 'one', 'three']) <class 'dict_keys'>

    8.0 values()函数

    描述:返回字典d中所有值的信息。

    语法:d.values()

    程序示例:

    d = {"one":1,"two":2,"three":3}
    print(d.values(),type(d.values()))

    程序运行结果:

    dict_values([2, 1, 3]) <class 'dict_values'>

    9.0 pop()函数

    描述:键存在则返回相应的值,同时删除该键值对,否者返回默认值d。

    语法: d.pop(key,d) -> v  删除指定的键并返回相应的值。如果未找到key,则返回d(如果给定),否则引发KeyError错误

    • key —— 要删除的键
    • d —— 如果没有指定要删除的key,则返回d值。

    程序示例:

    d = {"one":1,"two":2,"three":3,"four":4,"five":5}
    print(d.pop("one")) #返回 键"one"的值
    print(d.pop("six",6)) #字典d中无 "six"键,返回d值给定
    print(d)
    print(d.pop("seven")) #字典d中无 "seven"键,且没有给定d值,程序报错

    程序运行结果:

    1
    6
    {'two': 2, 'five': 5, 'four': 4, 'three': 3}
    ---------------------------------------------------------------------------
    KeyError                                  Traceback (most recent call last)
    <ipython-input-162-3859af2a44e8> in <module>()
          3 print(d.pop("six",6)) #字典d中无 "six"键,返回d值给定
          4 print(d)
    ----> 5 print(d.pop("seven")) #字典d中无 "seven"键,且没有给定d值,程序报错
    
    KeyError: 'seven'
    

    10.0 popitem()函数

    描述:随机从字典d中取出一个键值对,并以元组(key,value)的形式返回,同时将该键值对从字典d中删除。若字典d为空,则引发KeyError。

    语法:d.popitem()  -> (k, v) 返回键值对

    程序示例:

    d = {"one":1,"two":2,"three":3,"four":4,"five":5}
    d1 = dict() #创建空字典
    print(d.popitem(),type(d.popitem))
    print(d1.popitem()) #字典d1为空,程序会报错

    程序运行结果:

    ('two', 2) <class 'builtin_function_or_method'>
    ---------------------------------------------------------------------------
    KeyError                                  Traceback (most recent call last)
    <ipython-input-173-20b7d2dafbc3> in <module>()
          2 d1 = dict()
          3 print(d.popitem(),type(d.popitem))
    ----> 4 print(d1.popitem()) #字典d1为空,程序会报错
    
    KeyError: 'popitem(): dictionary is empty'
    

    注意 pop()函数 和 popitem()函数 的区别。

    11.0 setdefault()函数

    描述:如果字典d存在键k,则返回d[k],否者返回d,并将d[k]的值设为d,且将该键值对(k,d)保存在字典d中。

    语法:d.setdefault(k,d)  -> d.get(k,d) , also set d[k]=d if k not in d

    • k —— 要查找或想要添加的键
    • d —— 如果字典d不存在k键,则返回d

    程序示例:

    d = {"one":1,"two":2,"three":3,"four":4,"five":5}
    print(d.setdefault("one",36)) #字典d中存在键"one",返回键"one",对应的值
    print(d.setdefault("six",6)) # 字典d中不存在键 "six",返回6,并将("six",6)键值对保存在字典d中
    print(d) #字典d增加了一对新的键值对。

    程序运行结果:

    1
    6
    {'two': 2, 'five': 5, 'six': 6, 'three': 3, 'four': 4, 'one': 1}

    12.0 update()函数

    描述:将a中的所有对象添加到字典d中

    语法:d.update(a) -> None 返回值为空

    a —— 可以是:

    • ①一个字典                                                                                                       
    • ②关键字 如 six=6
    • ③一个包含一个及一个以上元组的列表
    • ④一个包含一个及一个以上列表的元组
    • ⑤一个zip()函数 如 zip(["a","b"],[1,2])   等

    程序示例:

    d = {"one":1,"two":2}
    d1 = {"three":3,"five":5} #字典
    ls = [("six",6),("seven",7)] #包含元组的列表
    t = (["eight",8],["ten",10]) #包含列表的元组
    d.update(d1)
    d.update(ls)
    d.update(t)
    d.update(eleven=11,twelve=12) #关键字
    d.update(zip(["thirteen","fourteen"],[13,14])) #zip
    print(d)
    print(d.update(d1)) #返回值为空

    程序运行结果:

    {'seven': 7, 'eight': 8, 'six': 6, 'ten': 10, 'eleven': 11, 'twelve': 12, 'two': 2, 'five': 5, 'thirteen': 13, 'three': 3, 'one': 1, 'fourteen': 14}
    None

     

     

     

     

     

     

     

     

    展开全文
  • 密码字典集合

    热门讨论 2020-07-27 23:32:50
    本密码字典内置28G超大密码字典(解压要很久)与多种不同的密码字典,希望网友们跑包顺利。
  • python 字典操作提取key,value

    万次阅读 多人点赞 2019-10-30 23:30:17
    python 字典操作提取key,value dictionaryName[key] = value 1.为字典增加一项 2.访问字典中的值 3、删除字典中的一项 4、遍历字典 5、字典遍历的key\value 6、字典的标准操作符 7...

    python 字典操作提取key,value dictionaryName[key] = value

    欢迎加入Python快速进阶QQ群:867300100

    微信号
    **1.为字典增加一项** ![这里写图片描述](https://imgconvert.csdnimg.cn/aHR0cDovL2ltZy5ibG9nLmNzZG4ubmV0LzIwMTcwODE0MTcxNzA5NjYy?x-oss-process=image/format,png) **2.访问字典中的值** ![这里写图片描述](https://imgconvert.csdnimg.cn/aHR0cDovL2ltZy5ibG9nLmNzZG4ubmV0LzIwMTcwODE0MTcxNzIzNzg2?x-oss-process=image/format,png) **3、删除字典中的一项** ![这里写图片描述](https://imgconvert.csdnimg.cn/aHR0cDovL2ltZy5ibG9nLmNzZG4ubmV0LzIwMTcwODE0MTcxODA4Nzcx?x-oss-process=image/format,png) **4、遍历字典** ![这里写图片描述](https://imgconvert.csdnimg.cn/aHR0cDovL2ltZy5ibG9nLmNzZG4ubmV0LzIwMTcwODE0MTcxODI5OTc3?x-oss-process=image/format,png) **5、字典遍历的key\value** ![这里写图片描述](https://imgconvert.csdnimg.cn/aHR0cDovL2ltZy5ibG9nLmNzZG4ubmV0LzIwMTcwODE0MTcxODQzOTIz?x-oss-process=image/format,png) **6、字典的标准操作符** ![这里写图片描述](https://imgconvert.csdnimg.cn/aHR0cDovL2ltZy5ibG9nLmNzZG4ubmV0LzIwMTcwODE0MTcxODU4MzEx?x-oss-process=image/format,png) **7、判断一个键是否在字典中** ![这里写图片描述](https://imgconvert.csdnimg.cn/aHR0cDovL2ltZy5ibG9nLmNzZG4ubmV0LzIwMTcwODE0MTcxOTE4MzI1?x-oss-process=image/format,png) **8、python中其他的一些字典方法** ![这里写图片描述](https://imgconvert.csdnimg.cn/aHR0cDovL2ltZy5ibG9nLmNzZG4ubmV0LzIwMTcwODE0MTcxOTM1OTQ4?x-oss-process=image/format,png) ![这里写图片描述](https://imgconvert.csdnimg.cn/aHR0cDovL2ltZy5ibG9nLmNzZG4ubmV0LzIwMTcwODE0MTcxOTQ4MzI1?x-oss-process=image/format,png) **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:直通车

    展开全文
  • 2019年最新密码字典,900万+个密码

    千次下载 热门讨论 2020-07-30 23:31:57
    本人看网络上的字典都不大,每次使用都要一个一个试。 所以准备把自己用了很久的一个字典分享出来 这个字典里包含了900万+个密码,大部分的wifi密码在里面都有
  • 字典

    2020-03-08 20:05:06
    字典 字典的查找 字典的修改 字典的删除 成员检测 成员检测 检测的是 key 的内容 字典中 keys 和values,以及items 是特殊词 # 空字典 a = {} a1 = dict() b = {"one":1, "two":2, "three":3} # 也可以用 等号...

    字典

    • 字典的查找
    • 字典的修改
    • 字典的删除
    • 成员检测
      • 成员检测 检测的是 key 的内容

    字典中 keys 和values,以及items 是特殊词

    # 空字典
    a = {}
    a1 = dict()
    b = {"one":1, "two":2, "three":3}  
    # 也可以用  等号  的关键字
    #  b1 = (one=1, two=2, three=3)
    # 用关键字参数的话不能用字符串进行创建
    print(b["three"])
    
    b["two"]= "二"
    del b["one"]
    print(b)
    print("*"*20)
    
    
    b["four"]= 4
    print(b)
    print("*"*20)
    
    
    for k in b.keys():   #  for k in b  一样的效果
        print(k,b[k])
    print("*"*20)
    for k,v in b.items():
        print(k,"----",v)
    
    3
    {'two': '二', 'three': 3}
    ********************
    {'two': '二', 'three': 3, 'four': 4}
    ********************
    two 二
    three 3
    four 4
    ********************
    two ---- 二
    three ---- 3
    four ---- 4
    
    bb = {k:v for k,v in b.items() }
    print(bb)
    
    {'two': '二', 'three': 3, 'four': 4}
    

    get 函数

    • a.get(“key”)
      • 如果key不存在就返回NONE
      • 但是可以自己设定没有返回什么值
      • a。get(“key”,100)
        • 如果找不到key,那么就返回100
    print(bb.get("two"))
    print(bb.get("asd"))
    
    二
    None
    
    # fromkeys  把两个类进行字典化,但是只是key有我们规定,value是同一的
    k = [1,2,3,4,5]
    v = [6,7]
    d = dict.fromkeys(k,v)
    print(d)
    
    {1: [6, 7], 2: [6, 7], 3: [6, 7], 4: [6, 7], 5: [6, 7]}
    
    展开全文
  • 数据结构之字典

    千次阅读 2018-04-04 11:51:06
    字典类型的容器在编程中的重要性不再言谈,通过现有典型互联网企业及传统企业专门部署redis集群服务器可知字典的编程、业务应用方面的重要性。 字典定义及初始化 非线性结构容器 key-value键值对的数据集合 可...
  • 什么是字典以及字典的特性

    千次阅读 2018-08-15 14:26:49
    一 什么是字典 dict全称dictionary,使用键-值(key-value)存储,value值可以是任意数据类型: int,float,long, complex, list, tuple,set, dict 1) 定义一个空字典 定义空字典:{ } ,dict( ) 2) 根据已有的...
  • 字典编程练习

    2018-10-17 16:35:23
    自定义函数twonums_sum(n, lst),在列表lst中查找是否有两数之和等于n,若有则返回两数的下标,否则返回-1。对于一个不包含重复数字的有序列表[1, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 15, 18, 19, 20, 21, 29, 34, ...
  • 字典树(前缀树)

    万次阅读 多人点赞 2018-08-24 00:41:07
    什么是字典树? 叫前缀树更容易理解 字典树的样子 Trie又被称为前缀树、字典树,所以当然是一棵树。上面这棵Trie树包含的字符串集合是{in, inn, int, tea, ten, to}。每个节点的编号是我们为了描述方便加上去...
  • 导入 import requests import pandas as pd import json 输入想要翻译的词并构建访问数据 i = input("请输入想要翻译的词:") ...smartresult=rule' headers = { 'User-Agent': 'Mozilla/5.0 (Windows NT 10.0;...
  • python字典中添加字典或者列表

    万次阅读 2018-11-11 14:21:14
    如何向字典中,添加字典? 例如 d1 = {a:1, b:2} d2 = {a:11, b:22, c:3} #目标:new_d(或者是d1) =d1 + d2 = {a:[1 , 11], b:[2, 22], c:[3]} 或者:new_d = { 1: {a:1, b:2}, 2:{a:11, b:22, c:3} } ...
  • 数据字典表设计

    万次阅读 2018-04-28 14:24:25
    2、用code标识数据,在存储时存储code就行了,这样即使数据改变了,也不影响程序表设计时达到的目标:使配置的数据(字典名称,字典值),不因数据的改变,影响数据的存储(这样就需要设计字典名称的code、字典 ...
  • python将字典转换成dataframe数据框

    万次阅读 多人点赞 2018-12-17 18:17:05
    需要将字典转换成dataframe来操作,并且将字典的key,value分别作为dataframe两列。 数据样例如下: 一个key只有一个value的字典如果直接转化成数据框会报错: 如下两种方法可达成目标。 一,将字典转换成...
  • 数据字典的范例

    万次阅读 2016-05-11 13:31:57
    http://faq.comsenz.com/library/database/x3/x3_index.htm
  • Python字典里面添加数据

    万次阅读 2019-07-23 17:09:01
    Python字典里面添加数据的方法 result = {'user':'sily','age':'18'} #执行以下代码 result['day'] = '2019-06-20' print(result) #输出结果 {'user':'sily','age':'18','day':'2019-06-20'} ...
  • 将pandas.Dataframe转化为字典格式的两种方法 da = df.to_dict(orient='records') das = df.to_json(orient='records')
  • python字典和JSON格式的转换

    万次阅读 2017-09-03 12:47:17
    首先引入 import json>>> d = {'s':'you','d':'are'} #给一个字典 >>> j = json.dumps(d) >>> type(j) str #已经转化为json字符串 >>> d1 = json.loads(j) >>> type(d1) dic #已经将json字符串转化为字典
  • python 如何判断字典是否为空?

    万次阅读 2018-12-17 13:55:23
    在python里,{},[],(),等都等价于False! if dict: print 'not Empty'  
  • Python -- 字典转换为列表

    万次阅读 2016-11-18 11:39:48
    字典转换为列表
1 2 3 4 5 ... 20
收藏数 711,925
精华内容 284,770
关键字:

字典