精华内容
下载资源
问答
  • Python 字典的缺点

    2020-05-14 23:30:46
    内存压缩 图像的特征匹配一般会用到字典的形式 ...如果数据量比较,那么字典就不适合了 如何解决这个问题? 我们不用字典的格式,用其他方式(了解一下zlib)进行数据的压缩,然后在存贮在内存中。 ...

    内存压缩

    图像的特征匹配一般会用到字典的形式

    key是图像的名称,value是特征(图像的特征匹配:需要建立庞大的字典)

    字典的缺点:本地10MB的数据在内存中会膨胀100倍

    虽然查询速度很快,但是会占用大量的内存空间

    如果数据量比较大,那么字典就不太适合了

    如何解决这个问题?

    我们不用字典的格式,用其他方式(了解一下zlib)进行数据的压缩,然后在存贮在内存中。

    展开全文
  • 后来就到网上查找python内存分析的工具,查了一点资料发现python有个meliae库操作非常方便,就使用分析了一下,发现不是节点多的原因0 0,是保存发送的t_id,用来标示返回的消息是那个发出的一个字典了。...
  • 在默认情况下,Python的新类和旧类的实例都有一个字典来存储属性值。这对于那些没有实例属性的对象来说浪费空间了,当需要创建大量实例的时候,这个问题变得尤为突出。 因此这种默认的做法可以通过在新式类中定义了...
  • Python学习指南

    2017-12-21 21:04:00
    摘要:马爸爸提出DT时代,数据成为了现在高科技企业竞争的最主要资产。...用来解决列表太大导致内存问题,这里使用生成器,可以一次只返回列表中的一个元素 Python列表生成器 Python元祖 Python切片 Python字典 ...

    摘要:马爸爸提出DT时代,数据成为了现在高科技企业竞争的最主要资产。

    Python基础

    1. Python数据类型转换
    2. Python_IO编程
    3. Python字符串操作
    4. Python列表
      一种列表创建的简单方式
    5. Python列表生成式
      用来解决列表太大导致内存问题,这里使用生成器,可以一次只返回列表中的一个元素
    6. Python列表生成器
    7. Python元祖
    8. Python切片
    9. Python字典
    10. Python迭代
    11. Python迭代器
    12. Python函数的参数
    13. Python访问限制

    Python提高

    1. Python闭包
    2. Python装饰器
    3. Python高阶函数
    4. Python高阶函数_map/reduce/filter函数
    5. Python实例属性限制 只针对当前类实例的属性起作用,对子类实例都没用
    6. Pytho的setter和getter方法
    7. Python枚举类

    Python自建模块

    1. Python自建模块_logging
    2. Python自建模块_collections
    3. Python自建模块_itertools

    Python网络

    1. TCP/IP简介
    2. TCP编程
    3. UDP编程

    Python爬虫

    首先分享两个python爬虫技能树
    python技能树
    python技能树2

    Python爬虫(一)_爬虫原理与数据抓取

    python爬虫(二)_HTTP的请求和响应

    python爬虫(四)_urllib2库的基本使用

    python爬虫(五)_urllib2:Get请求和Post请求

    python爬虫(六)_urllib2:handle处理器和自定义opener

    python爬虫(七)_urllib2:urlerror和httperror

    Python爬虫(八)_Requests的使用

    Python爬虫(九)_非结构化数据与结构化数据

    Python爬虫(十)_正则表达式

    Python爬虫(十一)_案例:使用正则表达式的爬虫

    Python爬虫(十二)_XPath与lxml类库

    Python爬虫(十三)_案例:使用XPath的爬虫

    Python爬虫(十四)_BeautifulSoup4 解析器

    Python爬虫(十五)_案例:使用bs4的爬虫

    Python爬虫(十六)_JSON模块与JsonPath

    Python爬虫(十七)_糗事百科案例

    Python爬虫(十八)_多线程糗事百科案例

    Python爬虫(十九)_动态HTML介绍

    参考

    Python 从入门到放弃
    菜鸟教程-python教程
    廖雪峰-python教程
    玄魂工作室
    崔庆才个人博客

    转载于:https://www.cnblogs.com/miqi1992/p/8082471.html

    展开全文
  • 在默认情况下,Python的新类和旧类的实例都有一个字典来存储属性值。这对于那些没有实例属性的对象来说浪费空间了,当需要创建大量实例的时候,这个问题变得尤为突出。    因此这种默认的做法可以通过在新式类...
    在默认情况下,Python的新类和旧类的实例都有一个字典来存储属性值。这对于那些没有实例属性的对象来说太浪费空间了,当需要创建大量实例的时候,这个问题变得尤为突出。
    

           因此这种默认的做法可以通过在新式类中定义了一个__slots__属性从而得到了解决。__slots__声明中包含若干实例变量,并为每个实例预留恰好足够的空间来保存每个变量,因此没有为每个实例都创建一个字典,从而节省空间。

           

    现在来说说python中dict为什么比list浪费内存?

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

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

           python解释器是Cpython,这两个数据结构应该对应C的哈希表和数组。因为哈希表需要额外内存记录映射关系,而数组只需要通过索引就能计算出下一个节点的位置,所以哈希表占用的内存比数组大,也就是dict比list占用的内存更大。


    如果想更加详细了解,可以查看C的源代码。python官方链接:https://www.python.org/downloads/source/

    如下代码是我从python官方截取的代码片段:


    List 源码:

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    typedef struct {
        PyObject_VAR_HEAD
        /* Vector of pointers to list elements.  list[0is ob_item[0], etc. */
        PyObject **ob_item;
      
        /* ob_item contains space for 'allocated' elements.  The number
         * currently in use is ob_size.
         * Invariants:
         *     0 <= ob_size <= allocated
         *     len(list== ob_size
         *     ob_item == NULL implies ob_size == allocated == 0
         * list.sort() temporarily sets allocated to -1 to detect mutations.
         *
         * Items must normally not be NULL, except during construction when
         * the list is not yet visible outside the function that builds it.
         */
        Py_ssize_t allocated;
    } PyListObject;


    Dict源码:

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    /* PyDict_MINSIZE is the minimum size of a dictionary.  This many slots are
     * allocated directly in the dict object (in the ma_smalltable member).
     * It must be a power of 2and at least 4.  8 allows dicts with no more
     * than 5 active entries to live in ma_smalltable (and so avoid an
     * additional malloc); instrumentation suggested this suffices for the
     * majority of dicts (consisting mostly of usually-small instance dicts and
     * usually-small dicts created to pass keyword arguments).
     */
    #define PyDict_MINSIZE 8
      
    typedef struct {
        /* Cached hash code of me_key.  Note that hash codes are C longs.
         * We have to use Py_ssize_t instead because dict_popitem() abuses
         * me_hash to hold a search finger.
         */
        Py_ssize_t me_hash;
        PyObject *me_key;
        PyObject *me_value;
    } PyDictEntry;
      
    /*
    To ensure the lookup algorithm terminates, there must be at least one Unused
    slot (NULL key) in the table.
    The value ma_fill is the number of non-NULL keys (sum of Active and Dummy);
    ma_used is the number of non-NULL, non-dummy keys (== the number of non-NULL
    values == the number of Active items).
    To avoid slowing down lookups on a near-full table, we resize the table when
    it's two-thirds full.
    */
    typedef struct _dictobject PyDictObject;
    struct _dictobject {
        PyObject_HEAD
        Py_ssize_t ma_fill;  /* # Active + # Dummy */
        Py_ssize_t ma_used;  /* # Active */
      
        /* The table contains ma_mask + 1 slots, and that's a power of 2.
         * We store the mask instead of the size because the mask is more
         * frequently needed.
         */
        Py_ssize_t ma_mask;
      
        /* ma_table points to ma_smalltable for small tables, else to
         * additional malloc'ed memory.  ma_table is never NULL!  This rule
         * saves repeated runtime null-tests in the workhorse getitem and
         * setitem calls.
         */
        PyDictEntry *ma_table;
        PyDictEntry *(*ma_lookup)(PyDictObject *mp, PyObject *key, long hash);
        PyDictEntry ma_smalltable[PyDict_MINSIZE];
    };


    PyObject_HEAD 源码:

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    #ifdef Py_TRACE_REFS
    /* Define pointers to support a doubly-linked list of all live heap objects. */
    #define _PyObject_HEAD_EXTRA            \
        struct _object *_ob_next;           \
        struct _object *_ob_prev;
      
    #define _PyObject_EXTRA_INIT 0, 0,
      
    #else
    #define _PyObject_HEAD_EXTRA
    #define _PyObject_EXTRA_INIT
    #endif
      
    /* PyObject_HEAD defines the initial segment of every PyObject. */
    #define PyObject_HEAD                   \
        _PyObject_HEAD_EXTRA                \
        Py_ssize_t ob_refcnt;               \
        struct _typeobject *ob_type;


    PyObject_VAR_HEAD 源码:

    1
    2
    3
    4
    5
    6
    7
    8
    9
    /* PyObject_VAR_HEAD defines the initial segment of all variable-size
     * container objects.  These end with a declaration of an array with 1
     * element, but enough space is malloc'ed so that the array actually
     * has room for ob_size elements.  Note that ob_size is an element count,
     * not necessarily a byte count.
     */
    #define PyObject_VAR_HEAD               \
        PyObject_HEAD                       \
        Py_ssize_t ob_size; /* Number of items in variable part */


    现在知道了dict为什么比list 占用的内存空间更大。接下来如何让你的类更加的节省内存。


    其实有两种解决方案:

           第一种是使用__slots__ ;另外一种是使用Collection.namedtuple 实现。


    首先用标准的方式写一个类:

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    #!/usr/bin/env python
     
    class Foobar(object):
        def __init__(self, x):
            self.x = x
     
    @profile
    def main():
        = [Foobar(42for in range(1000000)]
     
    if __name__ == "__main__":
        main()

          

    然后,创建一个类Foobar(),然后实例化100W次。通过@profile查看内存使用情况。


    运行结果:

    wKiom1WwlWTylNptAAG3zQCA3yg271.jpg


    该代码共使用了372M内存。


    接下来通过__slots__代码实现该代码:

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    #!/usr/bin/env python
     
    class Foobar(object):
        __slots__ = 'x'
        def __init__(self, x):
            self.x = x
    @profile
    def main():
        = [Foobar(42for in range(1000000)]
     
    if __name__ == "__main__":
        main()



     运行结果:

    wKiom1WwlrPiBsF0AAGoM0KZreE433.jpg


    使用__slots__使用了91M内存,比使用__dict__存储属性值节省了4倍。


            其实使用collection模块的namedtuple也可以实现__slots__相同的功能。namedtuple其实就是继承自tuple,同时也因为__slots__的值被设置成了一个空tuple以避免创建__dict__。


    看看collection是如何实现的:

    wKiom1WwmRiAi9O3AAFU03P0_VM849.jpg


    collection 和普通创建类方式相比,也节省了不少的内存。所在在确定类的属性值固定的情况下,可以使用__slots__方式对内存进行优化。但是这项技术不应该被滥用于静态类或者其他类似场合,那不是python程序的精神所在。


    本文出自 “David” 博客,请务必保留此出处http://davidbj.blog.51cto.com/4159484/1677587

    展开全文
  • 单词词典里面基本只要保存词的词性的频率,另外考虑到一次性把词典读入内存的消耗太大,必须把词典分块,当有需求的时候才将特定 的块装载进内存中。在这样的需求下,设计采用如下结构的词典:+-------------+ ...

    单词词典里面基本只要保存词的词性的频率,另外考虑到一次性把词典读入内存的消耗太大,必须把词典分块,当有需求的时候才将特定

    的块装载进内存中。在这样的需求下,设计采用如下结构的词典:

    +-------------+
    | Header      | -----> 包括词数量,总频率,索引开头位置,索引大小等
    +-------------+
    | Index       | -----> 每个索引项对应于一个词表块。索引项指示了词表块的位置大小等信息。
    +-------------+
    | Blocks      | -----> 以首字分区的块。
    +-------------+


    建立完成的单词词典有4Mb,180k+的单词。大概足够了。

    接下来要建立短语词典了。这个稍微麻烦一点。手头上的材料有一大堆网上的新闻。原则上把这些新闻进行分词,然后把两两邻接的词拼凑在一起,再将结果进行统计就可以了。但麻烦在于手头上没有好的分词算法,而且如果按照某一种分词方法对句子分词,必然使得到的短语字典的统计概率和该分词算法的行为高度一致,就失去了一般性。考虑再三,决定不采用任何方法进行预分词。直接暴力一点,把句子里所有可能的分词都找出来,一起统计其概率。在大量语料的帮助下,不合理的短语或词的组合应该有较低的出现概率,可以在最终根据概率大小进行筛选的时候把它们去掉。

    第一版短语字典选用了大概130M作用的新闻作为语言来源。python的效率实在称不上高,第一次运行用了30+分钟,内存使用更是惊人的达到1G+。字典里面短语的有一百多万,我原以为每个短语需要的字节数大概为短语的长度加上一些字典和数据结构的开销,大概几十字节,一共也就一两百个M的内存消耗。照这趋势我那3G内存可受不了。。。一开始我还以为什么地方有泄漏,不过用gc模块查看后发现内存的使用挺正常,猜想大概是python的dict使用效率不高吧。。。

    为了验证猜想,写了一段小程序进行实验。简单的说就是往一个字典里面不断的添加数据,然后观察内存的使用。字典的key是不大于10的字符串,value是4字节int。加上一些存储用指针之类,每组数据本身使用的内存应该在30字节左右。然后运行程序,配合task manager看内存的使用(高级一点的方法是heapy)。当字典里的数据个数达到8m个的时候,内存使用了700M+,大约每个数据100个字节。

    看来的确是python的内存消耗要超过我的预期。这样一来就只能从节省内存上下功夫了。好在一开始设计字典存储结构的时候就考虑到内存占用的问题,只要字典存进了磁盘,之后的数据可以load on demand。于是在建立字典的时候周期性的存盘,这样虽然会付出一些存盘的开销,内存的使用可以降低不少。再次运行,峰值内存占用400M左右,更重要的是随着数据的增多,内存使用增长的速度逐渐变慢,而不是原来的近乎线性增长了。

    最终获得的短语词典包含7.3m个项,平均出现频率为4.2。对短语的出现频率进行统计,结果有4.8m个短语出现次数为1,1.5m个短语出现次数为2或3。由于我们采用的策略,这些短语很有可能是一些错误分词的结果,或者是一些不常见词。为了减少词典的体积,这6.3m个数据直接被忽略,词典的体积被缩小到原来的1/7,大约10mb。

    以下列举了几个不同频率的短语:

    的时候: 16134
    我们的: 8483
    都没有: 4057
    是非常: 2346
    也已经: 1091
    都应该: 562

    展开全文
  • python处理大数据

    千次阅读 2016-05-16 23:05:32
    字典太大并不适合这种数据类型。 列表也不是存贮效率高的一种方式,通常我们大数据量计算会使用array,最差也要使用blist。 另外range也不可以的。要用xrange。xrange通常不消耗多少内存。range会用很多内存。 你...
  • 内置的包括数字、字符串、布尔、列表、元组、字典、Bytes、集合这些常用的以及一些不常用的数据类型。 而自定义的,一般以类的形式,根据需要组合以上内置类型成为独特的数据类型。 数据类型是Python语言非常重要...
  • 题目描述 代码实现 input_list = input()....Python处理这种问题,因为有列表、字典这些数据结构的存在,大大简化了实现的难度,但你也能看到弊端就是内存占用比较,我真是Python了!! 知识点总结 1.list...
  • 首先获取所有要爬取的URL,在这里不建议使用集合,字典或列表的数据类型来保存这些URL,因为数据量太大,太消耗内存,这里,python的生成器就发挥作用了。 ''' 遇到不懂的问题?Python学习交流群:821460695满足你的...
  • 本章分为三个模块:列表、元组、字典。 序列:一块用于存放多个值的连续内存空间,并按一定顺序排列 索引:序列中每个元素的编号。这个编号是从0开始的。 但是有一点要说的是:索引可以为负数(是不是很神奇)而且...
  • 检索模块设计的粗糙,速度慢 没有设计反馈系统,系统无法自动升级 主要还是慢和精度不高(这么点图片,聚类就花了很久) 1、使用k-means聚类,除了其K和初始聚类中心选择的问题外,对于海量数据,输入矩阵的巨大...
  • “结巴”中文分词:做最好的 Python 中文分词组件 "Jieba" (Chinese for "to stutter") Chinese text segmentation: built to be the best Python Chinese word segmentation module. Scroll down for English ...
  • 准备数据,参考data和vocab目录,可用pre_data/vocab.py处理出字典(每个data文件不能太大,否则内存不足) 训练模型train_elmo.py 输出模型dump_weights.py 把options.json里的261改成262 输出单词嵌入到hdf5文件...
  • 最新版数据太大,我已经把数据库压缩成 stardict.7z 了,外面默认的 ecdict.csv 算是一个基础版本(76 万词条)。 模糊匹配 数据库中有一个隐藏字段,叫做 sw,这是 strip-word 的缩写,意思是单词字符串经过 strip...
  • OCR 文字识别 、从包含表格的扫描图片中识别表格和文字、语声迁移、Python口语自然语言处理工具集(英文)、 similarity:相似度计算工具包,java编写、海量中文预训练ALBERT模型 、Transformers 2.0 、基于规模音频...
  • 公司里,只负责很小很小一块的镙丝钉,位置也不稳固啊。 所以,如果你不是立志成为某方面的专家,那就做一个全栈工程师吧。 ④ 调试很重要 都说代码是3分写7分调,各种调试调优技术,可以为你的升职加薪加一把...
  • 【超全golang面试题合集+golang学习指南+golang知识图谱+成长路线】 一份涵盖部分golang程序员所需要掌握的核心知识。 脑图持续不断更新中,在线查看地址 后续文章和内容会不断更新到 github项目 中,...
  • 1.1.6 从innodb的索引结构分析,为什么索引的 key 长度不能长 1.1.7 MySQL的数据如何恢复到任意时间点? 1.1.8 NFS 和 SMB 是最常见的两种 NAS(Network Attached Storage)协议,当把一个文件系统同时通过 ...
  • 现在的处理手段,在词粒度的错误召回还不错,但错误纠正的准确率还有待提高,更多优质的纠错集及纠错词库会有提升,我更希望算法上有更的突破。 另外,现在的文本错误不再局限于字词粒度上的拼写错误,需要提高...
  • Redisson : Redisson是架设在Redis基础上的一个 Java 驻内存数据网格(In-Memory Data Grid),支持超过 30 个对象和服务:Set,SortedSet, Map, List, Queue, Deque ......。更多介绍请看:《Redisson 项目介绍》 ...
  • 经典设计模式总共有23种(现在远不止23种了,还有一些变种),全部掌握难度太大了,我们只需要掌握一些常用的就好了,必须要掌握的我用小红旗已经标出来了。 怎么学? UML 学习 学习设计模式之前必须要学习 UML。...

空空如也

空空如也

1 2
收藏数 27
精华内容 10
关键字:

python字典内存太大

python 订阅