标签: Python

  • 避免Python中的递归调用问题:如何正确使用__getattr__和__setattr__方法

    递归调用是指一个函数或方法在执行的过程中,直接或间接地调用了自身,从而形成了无限循环的调用关系,导致程序崩溃或陷入死循环。在 Python 中,由于方法和属性的调用方式不同,很容易出现递归调用的问题,特别是在使用 __setattr__ 和 __getattr__ 等特殊方法时。

    RecursionError: maximum recursion depth exceeded 

    在相关开发的项目中,为了便于数据库和业务的交互,定义了一些Model来处理任务,为了简便完成Model的开发,采用了 __setattr__ 和 __getattr__ ,但却因此产生了递归调用的问题。以下是出错的代码:

    class Person(object):
        def __init__(self, *args, **kwargs):
           self.document = {"genre": "XXX", "age": "XXX"}
        def __getattr__(self, name):
            if name in self.document:
                return self.document[name]
            else:
                raise AttributeError(f"'{self.__class__.__name__}' object has no attribute '{name}'")
        def __setattr__(self, name, value):
            # 这里的self.document会触发__getattr__方法
            # 从而在__getattr__里面的self.document又继续
            # 触发__getattr__,从而产生递归调用问题
            if name in self.document: 
                self.document[name] = value
            else:
                super().__setattr__(name, value)
    person = Person()
    person.age = 18 

    为了解决这个问题,我们可以在类中使用 self.__dict__.setdefault() 方法或者在 init 方法中使用 self._document = {} 来初始化实例属性。这样做的好处是,实例属性和类属性的作用域得到了清晰的界定,避免了递归调用的问题。此外,如果要修改实例属性,我们可以直接使用 setattr() 方法,而不是直接赋值,这样也可以避免递归调用的问题。

    下面是一个示例代码,演示了如何使用 getattrsetattr 方法,避免递归调用的问题:

    class Person(object):
        def __init__(self, *args, **kwargs):
           # 初始化实例下的__dict__
           self.__dict__.setdefault('document', {})
           self.document = {"genre": "XXX", "age": "XXX"}
        def __getattr__(self, name):
            if name in self.document:
                return self.document[name]
            else:
                raise AttributeError(f"'{self.__class__.__name__}' object has no attribute '{name}'")
        def __setattr__(self, name, value):
            if name in self.document: 
                self.document[name] = value
            else:
                super().__setattr__(name, value)
    

    在这个示例代码中,我们使用了 self.__dict__.setdefault() 方法来初始化实例属性。这样,就可以避免递归调用的问题,确保程序能够正确地运行。

    另外在类属性这里初始化一个document = {}也能解决问题,但是需要注意类属性和实例属性的作用域,避免产生混淆,导致程序出错。

    class Person(object):
        document = {"genre": "XXX", "age": "XXX"}
        def __init__(self, *args, **kwargs):
            pass
        def __getattr__(self, name):
            if name in self.document:
                return self.document[name]
            else:
                raise AttributeError(f"'{self.__class__.__name__}' object has no attribute '{name}'")
    
        def __setattr__(self, name, value):
            if name in self.document: 
                self.document[name] = value
            else:
                super().__setattr__(name, value)

    Python的__getattr__和__setattr__是在开发中很好用的方法,能大大提高开发效率,但是递归调用的问题不能忽视,以上便是针对这个问题的解决方案。

  • Python描述符(descriptor)解密,文章地址

    这篇文章解决了困扰我许久的疑问,实在太好了,网上所有的乱七八糟的说明,还不如这个来的完善,直接将文章链接放在最上面。

    原文链接: Chris Beaumont 翻译: 极客范 慕容老匹夫
    译文链接: http://www.geekfan.net/7862/

  • python 位操作符 左移和右移 运算

    左移和右移N位等同于无溢出检查的2的N次幂运算:2**N
    <<左移 运算规则: 按二进制形式把所有的数字向左移动对应的位数,高位移出(舍弃),低位的空位补零。 语法格式: 需要移位的数字<<移位的位数 例如:3<<2则是将数字3左移动2位 计算过程: 3<<2首先把3转换为二进制数字00000000000000000000000000000011 然后把该数字高位(左侧)的两个零移出,其他的数字都朝左平移2位,最后在低位(右侧) 的连个空位补零。则得到的结果是00000000000000000000000000001100, 则转换为十进制是12 数学意义: 在数学没有溢出的前提下,对于正数和负数,左移以为都相当于乘以2的1次方,左移n位 就相当于乘以2的n次方 >>右移
    运算规则:
    按二进制形式把所有的数字向右移动对应的位数,低位移出(舍弃),高位的空位补符号位
    即正数补0,负数补1
    语法规则:
    需要移位的数字>>移位的次数
    例如:11>>2则是将数字11右移2位
    计算过程:
    11的二进制形式为:00000000000000000000000000001011然后把低位的最
    后两个数字移出,因为该数字是正数,所以在高位补0,则得到的最终的二进制结果为:
    00000000000000000000000000000010转换为十进制数为3
    数学意义:
    右移一位相当于除以2,右移n位相当于除以2的n次方,这里取的是商,不要余数

    转自:http://wangyan112.blog.51cto.com/3383033/1320143

  • Python 继承使用super出错

    Python 2.2以后使用super继承的父类属性的时候会报错,这篇文章通过讲解新式类和旧类的区别来解决super报错的问题。

    在Python的类中去继承父类的属性, 一般的写法为:

    [python]
    class Father:
    def __init__(self):
    print "I’m Father"

    class Child(Father):
    def __init__(self):
    Father.__init__(self)
    print "I’m Child"
    >>>f = Child()
    I’m Father
    I’m Child
    [/python]

    如果在多重继承的问题中,例如菱形继承(钻石问题),则需要用到super来解决。但是super只能用在继承基类”object”的新式类中,不能用于以前的经典类,否则报错:

    [python]
    class Father:
    def __init__(self):
    print "I’m Father"

    class Child(Father):
    def __init__(self):
    super(Child, self).__init__()
    print "I’m Child"
    >>>f = Child()
    Traceback (most recent call last):
    File "<stdin>", line 1, in <module>
    File "<stdin>", line 3, in __init__
    TypeError: must be type, not classobj
    [/python]

    原因如下:

    解决的方法是设置Father继承Object

    [python]
    class Father(object):
    def __init__(self):
    print "I’m Father"

    class Child(Father):
    def __init__(self):
    super(Child, self).__init__()
    print "I’m Child"
    >>>f = Child()
    I’m Father
    I’m Child
    [/python]

    以下关于《旧类和新式类》的内容摘自:http://blog.csdn.net/jb19900111/article/details/20228341

    • python的新式类是2.2版本引进来的,我们可以将之前的类叫做经典类或者旧类。
    • 为什么要在2.2中引进new style class呢?官方给的解释是:为了统一类(class)和类型(type)。
    • 在2.2之前,比如2.1版本中,类和类型是不同的,如a是ClassA的一个实例,那么a.__class__返回 ‘ class __main__.ClassA‘ ,type(a)返回总是<type ‘instance’>。而引入新类后,比如ClassB是个新类,b是ClassB的实例,b.__class__和type(b)都是返回‘class ‘__main__.ClassB’ ,这样就统一了。
    • 引入新类后,还有其他的好处,比如更多的内置属性将会引入,描述符的引入,属性可以来计算等等。
    • 为了向前兼容,默认情况下用户定义的类为经典类,新类需要继承自所有类的基类 object 或者继承自object的新类。
    • 值得注意的地方是,虽然使用的是最新的python(2.7),但是一些特性不会在旧式类起作用。
    • 所以,为了确保自己使用的是新式类,有以下方法:
      • 把这个赋值语句放在类模块代码的最前面 __metaclass__ = type(前面有提过)。
      • 自己的类都从内建类object直接或者间接地继承。
      • 如果不需要兼容旧式类,旧版本的类,那么就保持都是新式类。
      • 当然,在Python3里面,不存在这些问题了,因为所有的类都是object类的子类(隐式)。
  • Pyinstaller 将Python程序转成EXE

    Pyinstaller 将Python程序转成EXE

    Pyinstaller可以将Python程序编译成可执行程序,它可以被用于多个平台,操作十分的简单。 这次将Wiki Export Tool图形化后,需要生成一个可执行的文件,这样其他用户可以不用安装相关包就可以直接使用,这时候需要用到Pyinstaller将Python的程序转成可执行文件。

    这篇文章将会以转Wiki Export Tool为例子,介绍一下简单的操作。

    (更多…)

  • Python-模块加载 包加载

    这是一篇关于Python加载目录中的模块的一个简单方法,可以用于模块开发。
    关于package
    通常包总是一个目录,可以使用import导入包:
    [python]
    import re #加载正则表达式
    [/python]
    或者from + import来导入包中的部分模块:
    [python]
    from time import datetime #从时间包中加载日期模块
    [/python]

    如何创建一个包呢?

    主要的一个文件是,包目录下为首的一个文件便是 __init__.py,内容可以为空。
    也就是说模块文件和子目录,假如子目录中也有 __init__.py 那么它就是这个包的子包了。

  • Python保留分隔符的Split

    Python牛逼小技巧,Python保留分隔符的Split方法。其实在Python手册里面写了很清楚,因为原来用不着,所以没注意,但是这次因为处理文本的时候,需要保留标点符号,因此特地的去查了一下。

    [python]
    >>>re.split(‘(W)’, ‘foo/bar spamneggs’)
    [‘foo’, ‘/’, ‘bar’, ‘ ‘, ‘spam’, ‘n’, ‘eggs’]
    [/python]

  • PYQT4的数据类型

    在使用PYQT写程序的时候,会遇到某些PYTHON中的函数不能用了,比如说针对QString就没有strip(),join的使用方式变成了list.join(“,”)逗号是分割符。究其原因是因为在使用PYQT读取数据后,数据类型已经不是在PYTHON上的数据类型了,随便找一个看看,比如
    [python]
    #文本编辑块
    self.textEdit_articlelist.toPlainText()
    #输出文本编辑内容类型
    print type(self.textEdit_articlelist.toPlainText())
    #得出其类别
    <class ‘PyQt4.QtCore.QString’>
    [/python]

    会发现她们的数据类型会是:

    那么要如何解决呢,很简单比如这个字符串类型的数据,通过str()转回到Python的数据类型就是了,就是这么简单的。

    附上Pyqt4的使用指南:http://pyqt.sourceforge.net/Docs/PyQt4/

  • [大数据处理]Python直接操作压缩包里面的文件

    大数据处理中,常常会遇到压缩后的数据包,比如BZ2,ZIP等格式,这里简单的介绍了Python在无解压的情况下读取BZ2压缩文件,另外通过lxml中iterparse()的对于XML大型文件处理的方法。

    在处理维基百科的DUMP包的时候,会遇到一个问题:大数据,几乎每一个DUMP在解压后都有400-500GB,没有解压之前如果是BZ2格式的话,大小也在20-30GB之间。
    对于大数据的一般处理顺序:解压压缩包,再处理。可是把所有压缩包解压,可能没有足够的硬盘空间, 而且也很费时间。那么就试试不解压的情况下来操作,整个过程都在Python 2.7.*的环境下运行。

    BZ2文件:

    [python]
    #加载bz2模块
    from bz2 import BZ2File as b2f

    fp = b2f("filename.bz2") #filename.bz2是要处理的压缩包名字
    line = fp.readline() #读取一行
    while line: #按行读取,并自动读完的时候停止
    print line
    line = fp.readline()
    [/python]

    现在我们知道了如何在不解压的情况下处理bz2格式的文件,那么维基百科提供的DUMP都按照BZ2格式的压缩,而且里面的文件是XML文件,那么该如何处理维基百科的数据呢?
    Python提供了xml.sax来处理XML大型文件,而且这个处理方式完全可以和上面的方式联合来直接操作20几个GB的数据包。这里就介绍一下操作方式,下面这段SAX代码引子别处,并且在上面做了一些修改, 源代码网址:http://my.oschina.net/renhc/blog/59646

    [python]
    from bz2 import BZ2File as b2f #加载bz2模块
    from xml.sax import parse, handler, SAXException

    class MyXMLSAXHandler(handler.ContentHandler):
    """
    用户自定义事件处理器
    """
    #文档开始事件处理
    def startDocument(self):
    print ‘Document Start…’

    #文档结束事件处理
    def endDocument(self):
    print ‘Document End…’

    #元素开始事件处理
    #"name"是节点名称,"attrs"是节点属性
    def startElement(self, name, attrs):
    print ‘encounter element(%s)’ % (name)

    #元素结束事件处理
    def endElement(self, name):
    print ‘leave element(%s)’ % (name)
    #内容事件处理
    def characters(self, content):
    if content.isspace(): #去掉内容中的空格
    return
    print ‘characters:’ + content

    try:
    fp = b2f("filename.bz2","r") #filename.bz2是要处理的压缩包名字
    parse(fp, MyXMLSAXHandler())
    except SAXException, msg:
    print msg.getException()
    except:
    print sys.exc_info()[0],sys.exc_info()[1]
    [/python]
    这段代码其实不难理解,类MyXMLSAXHander继承了handler.ContentHandler, 在parse()分析XML文件是,从头到尾像流水一下的处理文件,类似与逐行读取,并在读取到相应的节点的时候,进行相关处理。
    也许通过xml.sax来控制数据还是比较复杂且花费时间,那么可以试试lxml中提供的iterparse(),这个方法基于SAX,操作大型数据就变的简单多了,类似的Python自身也提供了iterparse()模块, 有兴趣的可以移步:
    http://docs.python.org/2/library/xml.etree.elementtree.html#xml.etree.ElementTree.iterparse, 小提示:xml.etree.ElementTree和xml.etree.cElementTree都可以用哦,后者基于C的模块,速度会更快一些。 废话不多说,直接进入lxml.etree.iterparse()的用法,后面清除内存的那块一定得加。
    [python]
    from bz2 import BZ2File as b2f
    from lxml import etree

    f1 = "filename.xml.bz2"
    fp = b2f(f1,"r")
    node_find = "page" #要寻找的节点的名字

    #fp上面的传送过来的一个Objet, 其实也可以是一个文件名。
    #end是某个节点的结尾
    tree = etree.iterparse(fp,events=("end",), tag=node_find)
    for event, elem in tree:
    #输出结果
    print etree.tostring(elem, encoding="utf-8", pretty_print=True,
    xml_declaration=True)

    #清除内存
    elem.clear()
    while elem.getprevious() is not None:
    del elem.getparent()[0]
    [/python]

    好了,就到这里,如问题请留言。

  • Python中def的内存处理

    python def定义了一个方法(函数/模块),他们的内存使用方式很简单,调用完就清楚内存,但是有特别的情况比如调用模块libxml2。

    python在通过def定义了一个方法后,每次调用这个模块,都将进行内存加载。但是一旦使用完整个方法并返回后,python的内存管理机制,将会自动将所有的内存清空。网上已经有很多文章讲解内存管理机制,因此这里就简单的引用一下别人的文章,做个记录。

    关于Python的内存管理机制,这里引用51cto的一篇文章中提到的:
    “在Python中,许多时候申请的内存都是小块的内存,这些小块内存在申请后,很快又会被释放,由于这些内存的申请并不是为了创建对象,所以并没有对象一级的内存池机制。
    这就意味着Python在运行期间会大量地执行malloc和free的操作,频繁地在用户态和核心态之间进行切换,这将严重影响Python的执行效率。为了加速Python的执行效率,Python引入了一个内存池机制,用于管理对小块内存的申请和释放。这也就是之前提到的Pymalloc机制。
    在Python 2.5中,Python内部默认的小块内存与大块内存的分界点定在256个字节,这个分界点由前面我们看到的名为SMALL_REQUEST_THRESHOLD的符号控制。
    也就是说,当申请的内存小于256字节时,PyObject_Malloc会在内存池中申请内存;当申请的内存大于256字节时,PyObject_Malloc的行为将蜕化为malloc的行为。当然,通过修改Python源代码,我们可以改变这个默认值,从而改变Python的默认内存管理行为。
    在一个对象的引用计数减为0时,与该对象对应的析构函数就会被调用。”

    引用地址:
    http://developer.51cto.com/art/201007/213585.htm