小编sat*_*oru的帖子

我试图让一个对象像内置一样list,除了它的值在修改后保存.

我提出的实现是list在一个PersistentList类中包装.对于可能更改列表的方法的每次访问,包装器委托给包装list,并在调用后将其保存到键值数据库.

码:

class PersistentList(object):
    def __init__(self, key):
        self.key = key 
        self._list = db.get(key, []) 

    def __getattr__(self, name):
        attr = getattr(self._list, name)
        if attr:
            if attr in ('append', 'extend', 'insert', 'pop',
                'remove', 'reverse', 'sort'):
                attr = self._autosave(attr)
            return attr
        raise AttributeError

    def _autosave(self, func):
        @wraps(func)
        def _(*args, **kwargs):
            ret = func(*args, **kwargs)
            self._save()
            return ret 
        return _

    def _save(self):
        db.set(self.key, self._list)

这个实现有几个问题:

1. 我必须像append每次访问时一样修饰方法,有没有更好的方法来装饰某些对象的多个方法？

2. 像l += [1,2,3]我没有实现iadd方法那样的操作不起作用. …

我读了一本/dev/random类似于无限文件的书,但是当我设置以下代码来查看内容的样子时,它什么都不打印.

with open("/dev/random") as f:
    for i in xrange(10):
        print f.readline()

顺便说一下,当我尝试这个时/dev/urandom,它起作用了.

我正在阅读collections.py昨天的源代码.

在namedtuple函数中,template生成一个字符串,然后exec在临时命名空间中编辑.

在命名空间dict中,property重命名为to _property和tupleto _tuple.

我想知道这背后的原因是什么.这个重命名有什么问题有助于避免？

有了pip 1.5.X,我们可以使用pip wheel来构建和缓存封装的车轮,然后使用--use-wheel具有pip install从缓存的车轮安装.

我正在尝试在环境设置脚本中使用此功能.这就是我正在尝试的:

pip wheel --wheel-dir=/tmp Cython==0.19.2
pip install Cython==0.19.2 --use-wheel --no-index --find-links=/tmp

我希望pip wheel在构建它之前检查轮子是否已经存在.但它似乎忽略了现有的轮子并且每次都建立.

有可能避免这种情况吗？

虽然numpy.nan不等于numpy.nan,但(float('nan'), 1)不等于float('nan', 1),

(numpy.nan, 1) == (numpy.nan, 1)

可能是什么原因？Python首先检查id是否相同？如果在比较元组的项目时首先检查身份,那么为什么不直接比较对象时检查它？

在Linux内核源代码中,list_splice实现了__list_splice:

static inline void __list_splice(const struct list_head *list,
                                 struct list_head *prev,
                                 struct list_head *next)
{
        struct list_head *first = list->next; // Why?
        struct list_head *last = list->prev;

        first->prev = prev;
        prev->next = first;

        last->next = next;
        next->prev = last;
}

是不是list已经指向链表的头部了？为什么我们需要list->next取而代之？

有时使用具有多重继承的mixin可以帮助我们提高代码的可重用性.

例如,以下设计

class FollowableMixin(object):
    def get_followers(self):
        ...
    ...

class User(FollowableMixin):
    ...

可以更好地重用,而不是简单地添加get_followers到User:

class User(object):
    def get_followers(self):
        ...
    ...

因为稍后我们可能会考虑支持其他潜在客户的可跟随实体get_followers:

class BookStore(FollowableMixin):
    ...

但是,如果过度使用此模式,代码可能会变得过于复杂.

class User(FollowableMixin, RunnableMixin, FlyableMixin, WhatMixin ...):
    ...

所有这些mixin类为您的类注入属性和方法,理解您的代码变得非常困难.例如,您不知道您调用的方法来自何处,并且此方法可能反过来包括在另一个mixin中调用方法...

我该怎么做才能简化这个程序？

为什么Python中的sys.maxint <(sys.maxint - 100 + 0.01)？

当我使用时ps -o pid,rss -p 1,我看到以下内容:

PID RSS
  1 784

但是当我查询rss时psutil,我得到一个不同的值:

>>> p = psutil.Process(1)
>>> print p.get_memory_info().rss
802816

是否有可能psutil使用不同的单位？我在文档中找不到任何相关信息.

例如,有长型的3个变量,我们添加a和b并获得s:

long a, b, s;
...
s = a + b

现在((s^a) < 0 && (s^b) < 0)意味着什么？

我在Python 的源代码中看到了这样的支票:

    if (PyInt_CheckExact(v) && PyInt_CheckExact(w)) {
        /* INLINE: int + int */
        register long a, b, i;
        a = PyInt_AS_LONG(v);
        b = PyInt_AS_LONG(w);
        i = a + b;
        if ((i^a) < 0 && (i^b) < 0)
            goto slow_iadd;
        x = PyInt_FromLong(i);
    }