字典 订阅
字典(拼音: 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:48:32
    目录 序言: 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

     

     

     

     

     

     

     

     

    展开全文
  • 什么是字典以及字典的特性

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

    一  什么是字典

    dict全称dictionary,使用键-值(key-value)存储,value值可以是任意数据类型: int,float,long, complex, list, tuple,set, dict

    1) 定义一个空字典

    定义空字典:{ } ,dict( )

    2) 根据已有的数据创建字典

    d = dict(a=1, b=2)
    print(d, type(d))

    users = ['user1', 'user2']
    passwds = ['123', '456']

    可以将两个列表转换成列表里面嵌套元组,也可以直接将其转换成字典

    二  字典的特性

    1)

    字典同集合一样,只支持成员操作符

    成员操作符, 默认判断key值是否存在

    2)  for循环

    for循环: 默认遍历字典的key值

    for+index:

    3) fromkeys第一个参数可以列表/tuple/str/set, 将列表的每一个元素作为字典的key值,
    并且所有key的value值一致, 都为'000000';
    print({}.fromkeys({'1', '2'}, '000000'))

    eg:随机生成100张卡号, 卡号的格式为610 334455 001 ---610 334455 100,其密码都为666666

    三   字典的增删改查

    1) 增加

    1>    d = dict(a=1, b=2)
    d['g'] = 10  #字典中没有,为添加
    d['a'] = 10  #字典中已存在,为修改
    print(d)

    2>    update:
     # 如果key值已经存在, 更新value值;
     # 如果key值不存在, 添加key-value值;
     d.update({'a':4, 'f':1})
     print(d)

    3>   setdefault

    # 如果key值已经存在, 不做修改;
    # 如果key值不存在, 添加key-value值;默认情况下value值为None
    d.setdefault('g', 10)
    print(d)

    2)  删除

    1>  pop:弹出指定key-value值

    2>  popitem:

    3>  del:

    4>  clear:

    3) 修改,查看

    services = {  ' http ' : 80 , ' mysq l ' : 3306  }

    查看字典里面所有的key值
    print(services.keys())

    查看字典里面所有的value值
    print(services.values())

    查看字典里面所有的key-value值
    print(services.items())

    4) 遍历:

    1>  直接的遍历value值

    2>  间接的遍历value值

    5)  查看指定key对应的value值

    注意: key不存在, 就会报错

    判断key值存不存在

    6)  get方法获取指定可以对应的value值

     如果key值存在, 返回对应的value值;
    如果key值不存在, 默认返回None, 如果需要指定返回的值, 传值即可

    7) 列表的去重

    1>  转换为集合(集合是不能重复的)

    li = [1, 2, 3, 4, 65, 1, 2, 3]
    print(list(set(li)))

     

    2>  通过字典的方式去重(字典的key值是不能重复的)

    li = [1, 2, 3, 4, 65, 1, 2, 3]
    print({}.fromkeys(li).keys())

    四  关于字典的一些案例分析

    1)  重复的单词: 此处认为单词之间以空格为分隔符, 并且不包含,和.;
      1. 用户输入一句英文句子;
      2. 打印出每个单词及其重复的次数

    method 1:

    method 2:

    2)  swhich语句

    python里面不支持switch语句

    但是可以通过字典来间接实现swhich功能

    也可以通过字典的 get 功能来更加快速的实现

    五  is  和  == 的区别

    变量:
             id: 在内存中存储的位置;id(a)
             value:==
             type:变量的数据类型;type(a)
    ==:value, type
    is: 三个都判断

    如果:a is b ====> True, a==b一定相等, 返回True;
    但是,a==b ====> True,  a is b 不一定

    六  深拷贝和浅拷贝的区别

    直接赋值(li1 = li): 只传递对象的引用, li1指向对象li的内存地址空间,
        因此, 原有列表li改变, 被赋值的li1也会做相应的改变.

    浅拷贝(三种实现方式 eg: li2=li.copy()):li和li2的内存地址不同,
        但是子对象的内存地址相同, 因此,原始数据改变 , 子对象也改变.

    深拷贝(import copy, eg: li3=copy.deepcopy(li)), li和li3的内存地址不同,
             包含子对象的拷贝, 所以原始对象改变并不会造成深拷贝里面任何子项的改变.

    ### 当深拷贝和浅拷贝, 针对的对象全部是不可变数据类型时, 两者效果相同;
    ### 当深拷贝和浅拷贝, 针对的对象包含是可变数据类型时, 两者才有上述区别

     浅拷贝的实现:
       - li . copy (  )
       - li [ : ]
       - copy . copy (  li  )

    实现深拷贝:
      - copy . deepcopy(  li  )

    展开全文
  • 字典编程练习

    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, ...

    自定义函数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, 54, 65],从键盘输入n,调用函数twonums_sum()输出满足条件的两个数的下标(找到一组即可且要求其中的一个数尽量小),若所有数均不满足条件则输出“not found”。

    def twonums_sum(n, lst):
        for i in range(len(lst)):
            for j in range(len(lst)):
                if lst[i]+lst[j] == int(n):
                    return (i, j)
        else:
            return 'not found'
    
    n = input('please input n: ')
    lst = [1, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 15, 18, 19, 20, 21, 29, 34, 54, 65]
    print(twonums_sum(n, lst))
    
    
    展开全文
  • 密码字典集合

    热门讨论 2018-04-19 14:53:28
    本密码字典内置28G超大密码字典(解压要很久)与多种不同的密码字典,希望网友们跑包顺利。
  • 字典

    2015-12-22 15:29:32
    字典是Python中唯一内建的映射类型,字典中的值并没有特殊的顺序,但是都存储在一个特定的键(Key)里。键可以是数字、字符串或无组。 整个字典是由一对大括号括起来,每个键和值之间用冒号(:)隔开,项之间用逗号...
  • 字典

    2019-02-14 21:04:14
    在Python中,字典用放在花括号{} 中的一系列键—值对表示,键—值 对是两个相关联的值。指定键时,Python将返回与之相关联的值。键和值之间用冒号分隔,而键—值对之间用逗号分隔。在字典中,你想存储多少个键—值对...
  • 字典

    2019-03-16 14:40:33
    字典,键(key)必须使用不可变类型。 字典,无序,所以直接输出时print和定义的顺序是不一样的额 字典的翻转: dict([(v,k)for k,v in zidian.iteritems()]) zip(zidian,values(),zidian.keys()) itertools模块 ...
  • 字典

    2020-09-18 17:57:30
    课程:字典 目标 字典的应用场景 创建字典的语法 字典常见操作 字典的循环遍历 一. 字典的应用场景 思考1: 如果有多个数据,例如:‘Tom’, ‘男’, 20,如何快速存储? 答:列表 list1 = ['Tom', '男', 20] ...
  • 创建字典的方法

    2020-10-19 01:36:42
    创建字典的方法: 方法一; c=dict(a=1,b=2,k=90)#通过dict函数创建字典 print© 方法二; di={‘q’:6,‘p’:9,‘l’:0} #直接通过键值对创建字典,{key1:value1,…} print(di) 方法三: #通过zip()函数,将可...
  • 导入 import requests import pandas as pd import json 输入想要翻译的词并构建访问数据 i = input("请输入想要翻译的词:") ...smartresult=rule' headers = { 'User-Agent': 'Mozilla/5.0 (Windows NT 10.0;...
  • 字典树(前缀树)

    万次阅读 多人点赞 2018-08-24 00:41:07
    什么是字典树? 叫前缀树更容易理解 字典树的样子 Trie又被称为前缀树、字典树,所以当然是一棵树。上面这棵Trie树包含的字符串集合是{in, inn, int, tea, ten, to}。每个节点的编号是我们为了描述方便加上去...
  • python 字典操作提取key,value

    万次阅读 多人点赞 2017-08-14 17:24:27
    python 字典操作提取key,value dictionaryName[key] = value 1.为字典增加一项 2.访问字典中的值 3、删除字典中的一项 4、遍历字典 5、字典遍历的key\value 6、字典的标准操作符 7...
  • 数据字典是什么

    万次阅读 多人点赞 2018-12-20 17:59:05
    数据字典 数据字典是一种通用的程序设计方法。可以认为,不论什么程序,都是为了处理一定的主体,这里的主体可能是人员、商品(超子)、网页、接口、数据库表、甚至需求分析等等。当主体有很多的属性,每种属性...
  • python3字典的排序

    万次阅读 多人点赞 2018-03-21 15:17:41
    平常学习了字典(dict),感觉还行。但一到用的时候,就感觉模棱两可。 于是就总结了字典的常见用法,以后可熟记于心。 - - - - - - - - - - - - - - - 更新日记:2019-05-21 通一表述:字典有两个参数,key, ...
  • Python之字典添加元素

    万次阅读 多人点赞 2019-01-05 16:30:24
    0、好吧,还是直接上干货,向字典中添加元素,即Entry,Python用的很巧妙啊,当发现字典中并没有你要的key后,干脆帮你添加进去了 from utils import printWithChinese book_dict = {"price": 500, "bookName": ...
  • 【SpringBoot】廿四、SpringBoot中实现数据字典

    万次阅读 多人点赞 2020-07-17 11:41:44
    我们在日常的项目开发中,对于数据字典肯定不模糊,它帮助了我们更加方便快捷地进行开发,下面一起来看看在 SpringBoot 中如何实现数据字典功能的 一、简介 1、定义 数据字典是指对数据的数据项、数据结构、数据流...
  • 在Python中,字典按值排序

    万次阅读 多人点赞 2018-09-06 15:37:28
    在Python中,字典按值排序 我们可以用sorted高阶函数或者用列表的.sort()方法。 目录 在Python中,字典按值排序 一、sorted高阶函数 二、列表的.sort()方法 三、扩展 四、后记 一、sorted高阶函数 这种...
  • VBA字典(详解,示例)

    万次阅读 多人点赞 2019-05-03 17:14:36
    字典主要作用:条件计数、条件求和、去重、匹配。 本篇主要介绍了VBA字典以上使用方法及注意事项。
  • kali骚操作之系统字典

    千次阅读 2019-10-31 21:08:47
    kali默认字典目录: /usr/share/wordlists/ 一、kali默认字典简单介绍 dirb big.txt #大的字典 small.txt #小的字典 catala.txt #项目配置字典 common.txt #公共字典 euskera.txt #数据目录字典 ...

空空如也

1 2 3 4 5 ... 20
收藏数 779,450
精华内容 311,780
关键字:

字典