dict 订阅
Dict
信息
操作系统
未知
开发语言
开源协议
未知
Dict
“划词翻译”就是指在网页中选中单词或词组,就会立即在鼠标旁出现该词组的翻译(中英)。 请在状态栏 Dict 项处切换词典开启/关闭。 使用方法: 点击状态栏大写'D'字样图标开启和关闭翻译(开启时图标为蓝色,关闭为灰色),快捷键 ctrl+alt+d。 用鼠标选中单词或者直接指向单词,稍等片刻,翻译结果将直接在鼠标旁出现。 鼠标划过翻译结果可听到单词发音,点击结果即跳转到详细结果页面。
收起全文
精华内容
下载资源
问答
  • python set、dictdict.keys 性能对比

    万次阅读 2019-09-16 17:02:51
    通常我用dict来保存词和词频。我常用的方式是: if word not in vocab_dict: vocab_dict[word] = 0 vocab_dict[word] += 1 用了很久觉得速度还行。 后来看到有大神是这么用的: if word not in vocab_dict....

     当我们统计文本的词频时,通常需要查询当前词是否已经出现过,如果出现过,那么次数增1。通常我用dict来保存词和词频。我常用的方式是:

    if word not in vocab_dict:
        vocab_dict[word] = 0
    vocab_dict[word] += 1

    用了很久觉得速度还行。 
    后来看到有大神是这么用的:

    if word not in vocab_dict.keys():
        vocab_dict[word] = 0
    vocab_dict[word] += 1

    感觉这样似乎合理一些,因为我要做的本来就是常看word是否是vocab_map的key.于是之后都用这种方式。 
    某天,处理大量文本,且文本属于开放领域,词汇量也大,采用第二种方式,速度极慢,这时候,以为是查询dict本身比较慢,并没有意识到是vocab_map.keys()的问题。于是,将词同时存入set,查询时查set,速度快了很多。

    if word not in vocab_set:
        vocab_dict[word] = 0
    vocab_dict[word] += 1

    抽取小部分数据,量化对比set、dict、dict.keys()的查询速度,结果如下: 
    1.查询vocab_dict,打印语句:

    print "time cost is %d ms." % ((end - begin).microseconds/1000)
    time cost is 175 ms.

    2.查询vocab_dict.keys(),打印语句如下:

    print "time cost is %d s." % ((end - begin).seconds)
    time cost is 45 s.

    3.查询vocab_set,打印语句:

    print "time cost is %d ms." % ((end - begin).microseconds/1000)
    time cost is 168 ms.

    和查询vocab_dict差不多。

    那么为什么dict.keys()查询速度比另外两个慢很多呢?这就要对比list、dict、set三种的数据结构了。 
    dict.keys()实际上是list(keys),是dict的所有key组成的list。查找一个元素是否在list中是以list的下标为索引遍历list.而查询是否在dict中,是将key以hash值的形式直接找到key对应的索引,根据索引可直接访问value。对量大的dict查询,自然是后者快很多。 
    而set和dict的存储原理基本是一样的,唯一不同的是,set没有value,只有key。对查询key是否在dict或sset内,效果基本上是一样的。

    由此,可以得出,如果存储的数据会被反复查询,且量大,那么,尽量不要用list,尽量用dict,如果元素不重复,用set更好。查询是否在dict内,也不要在用dict.keys()
     

    展开全文
  • Python中dict的打印

    万次阅读 2018-04-18 18:41:26
    dict = {'name':'ngy','age':23,'height':180} 1. 最简单的方式: print(dict) 结果: {'name': ngy, 'age': 23, 'height': 180} dict是无序的,若想有序打印,将其转化为list排序, 按key值排序,然后可以用...
    dict = {'name':'ngy','age':23,'height':180}

    1. 最简单的方式:

    print(dict)

    结果:

    {'name': ngy, 'age': 23, 'height': 180}

    dict是无序的,若想有序打印,将其转化为list排序,

    按key值排序,然后可以用PrettyTable输出:

    list = sorted(dict.items(), key = lambda d:d[0])
     
    table = PrettyTable(["key","value"])
    table.align["key"] = "l"
    table.padding_width = 1
    for tup in list:
    	table.add_row([tup[0], tup[1]])
     
    print(table)
    

    按value值排序:

    list = sorted(dict.items(), key = lambda d:d[1])
    

    2. 逐个打印key:

    for key in dict.keys():
        print('key = {}'.format(key))

    结果:

    key = name

    key = age

    key = height

    3. 逐个打印value:

    for value in dict.values():
        print('value = {}'.format(value))

    结果:

    value = ngy

    value = 23

    value = 180

    4. 逐个打印key:value:

    for key,value in dict.items():
        print('{key}:{value}'.format(key = key, value = value))

    结果:

    name:ngy

    age:23

    height:180

     

     

    展开全文
  • Python 函数dict() 和 dict

    2018-12-21 23:24:03
    dict() 作用:dict() 函数用于创建一个字典。返回一个字典。 语法: class dict(**kwarg) class dict(mapping, **kwarg) class dict(iterable, **kwarg) 参数说明: **kwargs -- 关键字 mapping -- 元素的...

     dict()

    作用:dict() 函数用于创建一个字典。返回一个字典。

    语法:

    class dict(**kwarg)
    class dict(mapping, **kwarg)
    class dict(iterable, **kwarg)
    

    参数说明:

    • **kwargs -- 关键字
    • mapping -- 元素的容器。
    • iterable -- 可迭代对象

    实例:

    >>>dict()                        # 创建空字典
    {}
    >>> dict(a='a', b='b', t='t')     # 传入关键字
    {'a': 'a', 'b': 'b', 't': 't'}
    >>> dict(zip(['one', 'two', 'three'], [1, 2, 3]))   # 映射函数方式来构造字典
    {'three': 3, 'two': 2, 'one': 1} 
    >>> dict([('one', 1), ('two', 2), ('three', 3)])    # 可迭代对象方式来构造字典
    {'three': 3, 'two': 2, 'one': 1}
    >>>

    python中的dict的详细介绍

    一、dict的特性

      dict是python中的一个可变的数据类型,用{}表示,dict的key必须是不可变的数据类型,而value的数据类型可以任意

      格式:{key:value,key:value,key:value}

      注:键值对如果是字符串使用单引号,最后一个键值对没有逗号

        不可变数据类型: 元组,bool,int , str 可以hash
        可变数据类型: dict ,list, set

    二、dict的方法:

      (1)增加的方法:dict有两种增加的方法

       ①第一种:如果没有的键值对,则进行添加,如果有,则将值进行覆盖

    dict1={'name':'jinxin','age':18,'male':'男'}
    print(dict1)
    dict1['high']=185
    print(dict1)  # {'name': 'jinxin', 'age': 18, 'male': '男', 'high': 185}
    dict1['age']=16
    print(dict1) #  {'name': 'jinxin', 'age': 16, 'male': '男', 'high': 185}

       ②:第二种:如果有键值对,不做任何改变,没有键值对,才进行添加

    dict1.setdefault("weight")
    print(dict1)  #{'name': 'jinxin', 'age': 16, 'male': '男', 'high': 185, 'weight': None}
    dict1.setdefault('weight','65kg')
    print(dict1)  #{'name': 'jinxin', 'age': 16, 'male': '男', 'high': 185, 'weight': None}
    dict1.setdefault('address','北京')
    print(dict1)  #{'name': 'jinxin', 'age': 16, 'male': '男', 'high': 185, 'weight': None, 'address': '北京'}

      (2)dict的删除方法

       ①:使用pop()删除,如果有键,则删除,如果没有则会报错,如果不希望出现报错信息,可以在删除的后面添加信息

    delDict={'name': 'jinxin', 'age': 16, 'male': '男', 'high': 185, 'weight': None, 'address': '北京'}
    # delDict.pop('age')  #dict的删除操作是有返回值的
    print(delDict.pop('age'))  # 16
    print(delDict)  #{'name': 'jinxin', 'male': '男', 'high': 185, 'weight': None, 'address': '北京'}
    print(delDict.pop('职业','没有此键'))  #没有此键

       ②:使用popitem()删除,随机删除,返回的是一个元组,元组里面存储的删除的键值,推荐使用pop()方法进行删除

    print(delDict.popitem())  # ('address', '北京') 随机删除,返回值是删除的键值对
    print(delDict)  #{'name': 'jinxin', 'male': '男', 'high': 185, 'weight': None}

       ③:使用del()删除,del()可以删除整个字典,也可以删除字典的某个键,如果删除的键不存在,则会出现报错

    del delDict['name']
    print(delDict)  #{'male': '男', 'high': 185, 'weight': None}
    
    #使用del清空列表
    del delDict
    print(delDict)  #delDict已经删除,报错

       ④:清空列表也可以使用clear()

     (3)dict的修改

      使用update()方法修改字典

    updateDict1={'name':'jinxin','age':18,'male':'男'}
    updateDict2={'name':'jordan','address':'北京海淀'}
    updateDict2.update(updateDict1)
    print(updateDict1) #{'name': 'jinxin', 'age': 18, 'male': '男'}
    print(updateDict2) #{'name': 'jinxin', 'address': '北京海淀', 'age': 18, 'male': '男'}

    (4)字典的查询

      ①:查询字典的键:调用keys()方法

        查询字典的值:调用values()方法

    # 字典的查
    dict1={'name':'jinxin','age':18,'male':'男'}
    print(dict1.keys()) #dict_keys(['name', 'age', 'male'])
    print(dict1.values()) #dict_values(['jinxin', 18, '男'])
    print(dict1.items())# dict_items([('name', 'jinxin'), ('age', 18), ('male', '男')])
    
    #打印dict1的键
    for i in dict1.keys():
        print(i )  # name age value
    
    #打印dict的值
    for v  in dict1.values():
        print(v) #jinxin 18 男

        打印字典的键值:

    dict1={'name':'jinxin','age':18,'male':'男'}
    
    for i in dict1.items():
        print(i)  # ('name', 'jinxin') ('age', 18) ('male', '男')
        
    for k,v in dict1.items():
        print(k,v)  # name jinxin  age 18   male 男

      ②:字典的get()方法:使用get()方法可以查询某个键是否存在,如果不存在此键,则会返回None,但是可以在get()方法中添加信息避免出现None

    dict1={'name':'jinxin','age':18,'male':'男'}
    print(dict1.get('name')) #jinxin
    print(dict1.get('address')) # None
    print(dict1.get('address','没有此键'))  #没有此键
    

    以下转自廖雪峰


    dict

    Python内置了字典:dict的支持,dict全称dictionary,在其他语言中也称为map,使用键-值(key-value)存储,具有极快的查找速度。

    举个例子,假设要根据同学的名字查找对应的成绩,如果用list实现,需要两个list:

    names = ['Michael', 'Bob', 'Tracy']
    scores = [95, 75, 85]
    

    给定一个名字,要查找对应的成绩,就先要在names中找到对应的位置,再从scores取出对应的成绩,list越长,耗时越长。

    如果用dict实现,只需要一个“名字”-“成绩”的对照表,直接根据名字查找成绩,无论这个表有多大,查找速度都不会变慢。用Python写一个dict如下:

    >>> d = {'Michael': 95, 'Bob': 75, 'Tracy': 85}
    >>> d['Michael']
    95
    

    为什么dict查找速度这么快?因为dict的实现原理和查字典是一样的。假设字典包含了1万个汉字,我们要查某一个字,一个办法是把字典从第一页往后翻,直到找到我们想要的字为止,这种方法就是在list中查找元素的方法,list越大,查找越慢。

    第二种方法是先在字典的索引表里(比如部首表)查这个字对应的页码,然后直接翻到该页,找到这个字,无论找哪个字,这种查找速度都非常快,不会随着字典大小的增加而变慢。

    dict就是第二种实现方式,给定一个名字,比如'Michael',dict在内部就可以直接计算出Michael对应的存放成绩的“页码”,也就是95这个数字存放的内存地址,直接取出来,所以速度非常快。

    你可以猜到,这种key-value存储方式,在放进去的时候,必须根据key算出value的存放位置,这样,取的时候才能根据key直接拿到value。

    把数据放入dict的方法,除了初始化时指定外,还可以通过key放入:

    >>> d['Adam'] = 67
    >>> d['Adam']
    67
    

    由于一个key只能对应一个value,所以,多次对一个key放入value,后面的值会把前面的值冲掉:

    >>> d['Jack'] = 90
    >>> d['Jack']
    90
    >>> d['Jack'] = 88
    >>> d['Jack']
    88
    

    如果key不存在,dict就会报错:

    >>> d['Thomas']
    Traceback (most recent call last):
      File "<stdin>", line 1, in <module>
    KeyError: 'Thomas'
    

    要避免key不存在的错误,有两种办法,一是通过in判断key是否存在:

    >>> 'Thomas' in d
    False
    

    二是通过dict提供的get方法,如果key不存在,可以返回None,或者自己指定的value:

    >>> d.get('Thomas')
    >>> d.get('Thomas', -1)
    -1
    

    注意:返回None的时候Python的交互式命令行不显示结果。

    要删除一个key,用pop(key)方法,对应的value也会从dict中删除:

    >>> d.pop('Bob')
    75
    >>> d
    {'Michael': 95, 'Tracy': 85}
    

    请务必注意,dict内部存放的顺序和key放入的顺序是没有关系的。

    和list比较,dict有以下几个特点:

    1. 查找和插入的速度极快,不会随着key的增加而增加;
    2. 需要占用大量的内存,内存浪费多。

    而list相反:

    1. 查找和插入的时间随着元素的增加而增加;
    2. 占用空间小,浪费内存很少。

    所以,dict是用空间来换取时间的一种方法。

    dict可以用在需要高速查找的很多地方,在Python代码中几乎无处不在,正确使用dict非常重要,需要牢记的第一条就是dict的key必须是不可变对象

    这是因为dict根据key来计算value的存储位置,如果每次计算相同的key得出的结果不同,那dict内部就完全混乱了。这个通过key计算位置的算法称为哈希算法(Hash)。

    要保证hash的正确性,作为key的对象就不能变。在Python中,字符串、整数等都是不可变的,因此,可以放心地作为key。而list是可变的,就不能作为key:

    >>> key = [1, 2, 3]
    >>> d[key] = 'a list'
    Traceback (most recent call last):
      File "<stdin>", line 1, in <module>
    TypeError: unhashable type: 'list'
    

    展开全文
  • python dict常用

    千次阅读 2017-12-14 20:31:18
    本文主要是python中dict常用的方法: list 转化为 dict dict遍历删除指定条件的元素 dict安装key或者value排序 dict的value统计计数 两个list转化为dictdef lst_2_dict(): """ combine two list to dict ...

    本文主要是python中dict常用的方法:

    1. list 转化为 dict

    2. dict遍历删除指定条件的元素

    3. dict安装key或者value排序

    4. dict的value统计计数


    两个list转化为dict

    def lst_2_dict():
        """
        combine two list to dict
        :return:
        """
        lst1 = ['a', 'b', 'c']
        lst2 = [1, 2, 3]
        # d = {k: v for k, v in zip(lst1, lst2)}
        d = dict(zip(lst1, lst2))
        print d
        # {'a': 1, 'c': 3, 'b': 2}
    

    删除dict中value < 0 的元素

    def iter_dict_remove():
        """remove item in dict while iteration it"""
        d_info = {'aa': -1, 'bb': 0, 'cc': 1, 'dd': 2}
    
        for k in d_info.keys():
            print k, d_info[k]
            if d_info[k] < 0:
                del d_info[k]
    
        print 'after del', d_info 
    

    按照key的顺序变量dict

    def iter_dic_sort():
        """iter dict by sorted keys"""
        d_info = {'33': 33, '88': 88, '22': 22, '44': 44}
        for k in sorted(d_info):
            print k, d_info[k]
    

    安装key或者value对dict排序:

    def dict_sort_by_value():
        dic_num = {'first': 11, 'second': 2, 'third': 33, 'Fourth': 4}
    
        # print all the keys
        print dic_num.keys()
        print list(dic_num)
        # ['second', 'Fourth', 'third', 'first']
    
        # print all the sorted keys
        print sorted(dic_num)
        # ['Fourth', 'first', 'second', 'third']
    
        print sorted(dic_num, key=str.lower)
        # ['first', 'Fourth', 'second', 'third']
    
        # print sorted values
        print sorted(dic_num.values())
        # [2, 4, 11, 33]
    
        # sorted by value
        sorted_val = sorted(dic_num.items(), key=operator.itemgetter(1))
        # [('second', 2), ('Fourth', 4), ('first', 11), ('third', 33)]
        print sorted_val
    
        # sorted by key
        sorted_key = sorted(dic_num.items(), key=operator.itemgetter(0))
        print sorted_key
        # [('Fourth', 4), ('first', 11), ('second', 2), ('third', 33)]
    
        dic_k_lst = {'11': [1, 2], 'ab': [3], 'cd': [0, -1, 2]}
        # Sort a dictionary by length of the value
        print sorted(dic_k_lst.items(), key=lambda item: len(item[1]))
        # [('ab', [3]), ('11', [1, 2]), ('cd', [0, -1, 2])]
    
        dic_k_set = {'11': {1, 2}, 'ab': {3}, 'cd': {0, -1, 2}}
        # Sort a dictionary by length of the value
        d_val_len = sorted(dic_k_set.items(), key=lambda item: len(item[1]))
        print d_val_len
        # [('ab', set([3])), ('11', set([1, 2])), ('cd', set([0, 2, -1]))]
        print d_val_len[0][1]
        # set([3])
        print len(d_val_len[0][1])
        # 1 (长度为 1)
    

    对dict的value计数:

    def dic_count_value():
        from collections import Counter
        dic_k_lst = {'11': None, 'ab': 3, 'name': 'xy', 'none': None, 'age': 26}
        print Counter(dic_k_lst.values())
        # Counter({None: 2, 'xy': 1, 26: 1, 3: 1})
    
        # 统计none与非none的数量
        count_none = 0
        count_not_none = 0
        for k in dic_k_lst.keys():
            if dic_k_lst[k] is None:
                count_none += 1
            else:
                count_not_none += 1
    
        print count_none, count_not_none
        # 2 3

    统计dict中每个list的长度:

    def count_val_lst_len():
        d = {'T1': ['eggs', 'bacon', 'sausage'], 'T2': ['spam', 'ham', 'monty', 'python']}
        print map(len, d.values())
        # [4, 3]
        print sum(map(len, d.values()))
        # 7
    

    dict value求和:

    def sum_dic_val():
        d_info = {'33': 1, '88': 2, '22': 3, '44': 4}
        print sum(d_info.values())
        # 10
    def dic_probability():
        p = {1: {1: 0.1, 2: 0.3}, 2: {1: 0.1, 2: 0.3}}
        # {1: {1: 0.1, 2: 0.3}, 2: {1: 0.1, 2: 0.3}}
        print p[2], p[2][2]
        # {1: 0.1, 2: 0.3} 0.3

    具体见本人的github

    参考:

    https://stackoverflow.com/questions/613183/how-to-sort-a-dictionary-by-value

    https://stackoverflow.com/questions/72899/how-do-i-sort-a-list-of-dictionaries-by-values-of-the-dictionary-in-python

    http://pythoncentral.io/how-to-sort-python-dictionaries-by-key-or-value/

    https://stackoverflow.com/questions/20464368/sort-a-dictionary-by-length-of-the-value

    展开全文
  • POST参数转为DICT

    千次阅读 多人点赞 2020-04-07 00:15:37
    POST参数转为DICT一、需求说明二、我的解决方案写在最后 一、需求说明 当我们使用requests库编写爬虫时,往往需要抓包分析其中的POST请求参数,然后再将其转为DICT类型。当我看到参数是这样时: dopost=login&...
  • 一般情况下,在用example_dict.keys()或者example_dict.values()取出字典中对应的键值时,取出的值总是会带有前缀,如下: 只需要前面加个list进行转化成列表,再str转化为字符串即可达到提取的目的: str(list...
  • load_state_dict(state_dict, strict=True)

    千次阅读 2019-09-30 15:39:51
    load_state_dict(state_dict, strict=True)[source] Copies parameters and buffers from state_dict into this module and its descendants. If strict is True, then the keys of state_dict must exactly match ...
  • 遍历dict

    千次阅读 2016-04-02 14:39:46
    遍历dict 由于dict也是一个集合,所以,遍历dict和遍历list类似,都可以通过 for 循环实现。 直接使用for循环可以遍历 dict 的 key: >>> d = { 'Adam': 95, 'Lisa': 85, 'Bart': 59 } >>> for key in d:...
  • dict过滤

    千次阅读 2016-09-22 18:47:02
    过滤很容易让人想到用filter()函数,如下:>>> dict1 = { 1: '1', 2: '2', 3: '3', 4: {'4': 5} } >>> filter(lambda x: x >= 3, dict1) [3, 4]这种方式产生的结果当然不是我们所要的。为了实现我们的目标,我们...
  • dict 语法:class dict(**kwarg)class dict(mapping, **kwarg)class dict(iterable, **kwarg)参数说明:**kwargs -- 关键字mapping -- 元素的容器。iterable -- 可迭代对象。返回值返回一个字典。● 字典是另一种可....
  • 一、关于dict()函数 二、代码(结果) 一、关于dict()函数 1.详情看网址:https://mail.python.org/pipermail/python-dev/2016-September/146327.html 2.3.6版本的Python已经使得dict变得紧凑以及关键字变得有序 ...
  • 词根dict表示“言,说”,以dict为词根常见的单词有predict,contradict,和dictionary等。在单词predict中,pre为前缀表示“提前”,dict表示“言,说”,“提前->说出来”,它是动词“预言,预测”。一般指...
  • torch.load
  • Python Dict

    2017-11-30 22:31:24
    避免 KeyError 发生,有两个办法: 一、是先判断一下 key 是否存在,用 in 操作符: if 'Paul' in d: ...二、是使用dict本身提供的一个 get 方法,在Key不存在的时候,返回None: >>> print d.get('Bart')
  • list和dict是python的数据类型;series是pandas的一种数据类型,Series是一个定长的,有序的字典,因为它把索引和值映射起来了。通过以下例子,可以更加清楚它们的数据表示。1、list to others# list data = [[2000...
  • 将两个深层的 dict 合成一个 dict 将 data_2 和 data_1 合成一个新的字典。 对于 data_2 和 data_1 都有的 key,合成规则为 data_2 的数据覆盖 data_1。 # -*- coding:utf-8 -*- """ @author: tz_zs """ raw_dict =...
  • Python dict方法

    2018-11-22 11:43:59
    dict 字典 #内置函数len(),max(),min()都是比较的键值,所以键值必须是相同类型,dict(二维元素),enumerate() dict1 = {5:2,2:3,3:'b',True:False};print(min(dict1)) dict2 = {'ac':1,'b':2};print(min(dict2)) ...
  • 摘要:普通字典,有序字典,dict添加键值对,添加 普通dict dict = {'A':'a'} # 添加值 dict[B]='b' 顺序dict:即字典中存储顺序能保持跟添加时的顺序一致 import collections dict={} dict = collections....
  • python dict用法

    千次阅读 2019-08-10 13:16:50
    python dict字典是另一种存储容器,可以存储任意类型的对象。 字典是以键值对(key: value)的方式进行存储,键值对之间用逗号隔开,整个字典包括在{ }中,格式如下: dict = {key1: value1, key2: value2} 键一般...
  • python dict函数

    千次阅读 2015-08-25 07:45:04
    print '--------------begin-dict------------------' #初始化一个字典 d = dict({'one': 1, 'two': 2}) print d d = dict(one=1, two=2) print d d = dict([(['one', 'two'][i - 1], i) for i in (1, 2)]) print d ...
  • 文章目录python中用dictdict.keys()查找目标值 python中用dictdict.keys()查找目标值 在python字典中进行查找操作时,通常用 xx in dict 或 xx in dict.keys() 方法,但这两种方法在内部实现与运行速度上存在...
  • 关于dict.key和dict.key()

    千次阅读 2018-08-01 23:38:16
    因为需要查看字典的键值,我对字典进行了dict.key的调用结果出现了以下情况 &lt;built-in method keys of dict object at 0x02D8AB20&gt; 后来结果查阅资料发现这是因为返回了一个循环体 于是进行dict.key...
  • python中dict函数 Python dict()函数 (Python dict() function) dict() function is a library function, it is used to create a dictionary with keywords( Ids) and values (s), it accepts a set of values with...
  • python dict

    千次阅读 2012-12-10 19:53:04
    python dict 博客分类:  python pythondict  初始化 构造方法创建 Python代码  d = dict()  d = dict(name="nico", age=23)  d = dict((['name', "nico"], ['age', ...
  • Redis dict

    千次阅读 2013-06-16 20:58:41
    今天看了redis dict部分的源码(dict.h,dict.c),跟大家分享一下。 这两个文件包含了redis的hashtable的接口和实现。 Redis中hashtable的主要特点是增量rehash,rehash毕竟是一个耗时的操作,redis把它分摊到...
  • torch之模型加载load_state_dict

    万次阅读 多人点赞 2019-09-02 11:04:35
    ERROR:PyTorch加载模型model.load_state_dict()问题,Unexpected key(s) in state_dict: "module.features…,Expected . 希望将训练好的模型加载到新的网络上。如上面题目所描述的,PyTorch在加载之前保存的模型...
  • 利用numpy保存dict

    千次阅读 2020-07-08 14:17:52
    dict是非常方便的数据结构,但传统dict的保存与读取操作比较麻烦。其实可以利用numpy非常方便的对dict进行保存与读取: import numpy as np np.save("data.npy", data) # 保存 data = np.load("data.npy", allow_...
  • feed_dict

    万次阅读 2018-06-17 14:25:07
    sess.run() 中的feed_dict我们都知道feed_dict的作用是给使用placeholder创建出来的tensor赋值。其实,他的作用更加广泛:feed 使用一个 值临时替换一个 op 的输出结果. 你可以提供 feed 数据作为 run() 调用的参数....
  • state_dict详解

    千次阅读 2020-06-07 14:15:23
    在pytorch中,torch.nn.Module模块中的state_dict变量存放训练过程中需要学习的权重和偏执系数,state_dict作为python的字典对象将每一层的参数映射成tensor张量,需要注意的是torch.nn.Module模块中的state_dict只...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 83,114
精华内容 33,245
关键字:

dict