为什么Borg模式比Singleton模式更好？

我问,因为我没有看到它们导致任何不同.

博格:

class Borg:
  __shared_state = {}
  # init internal state variables here
  __register = {}
  def __init__(self):
    self.__dict__ = self.__shared_state
    if not self.__register:
      self._init_default_register()

辛格尔顿:

class Singleton:
  def __init__(self):
    # init internal state variables here
    self.__register = {}
    self._init_default_register()

# singleton mechanics external to class, for example this in the module
Singleton = Singleton()

我想在这里显示的是服务对象,无论是作为Borg还是Singleton实现,都有一个非常重要的内部状态(它提供了一些基于它的服务)(我的意思是它必须是有用的东西,它不是Singleton/Borg只是为了有趣).

而且这个州必须被引入.这里的Singleton实现更直接,因为我们将init视为全局状态的设置.我发现Borg对象必须查询其内部状态以查看它是否应该自行更新.

你拥有的内部状态越多,情况就越糟糕.例如,如果对象必须侦听应用程序的拆除信号以将其寄存器保存到磁盘,那么该注册也应该只执行一次,使用Singleton会更容易.

Python有一个标志-O,你可以用它来执行解释器.该选项将生成"优化"字节码(写入.pyo文件),并给出两次,它将丢弃文档字符串.从Python的手册页:

-O启用基本优化.这会将已编译(字节码)文件的文件扩展名从.pyc更改为.pyo.给定两次,导致文档字符串被丢弃.

我认为这个选项的两个主要特点是:

• 删除所有断言语句.为了速度,这可以防止腐败的程序状态.但是,你不需要大量的断言声明才能有所作为吗？你有任何值得的代码(并且理智吗？)

• 剥离所有文档字符串.什么应用程序的内存使用如此关键,这是一个胜利？为什么不将所有内容都推入用C编写的模块？

这个选项有什么用？它有真实世界的价值吗？

我有点偶然发现了一个错误,你尝试从NSMutableArray中删除对象,而其他对象被添加到其他地方.为了简单起见,我不知道如何修复它.这是我正在做的事情:

我有4个定时器调用4个不同的方法,将对象添加到同一个数组.现在,当我按下某个按钮时,我需要删除阵列中的所有对象(或至少一些).所以我试图首先使所有4个计时器无效,然后用数组做我想要的工作,然后启动计时器.我认为这会有用,因为我不再使用计时器来枚举数组,但看起来它不起作用.

这里有什么建议？

在Python 3.1中,我在builtins模块中有一个新的内置函数:

__build_class__(...)
    __build_class__(func, name, *bases, metaclass=None, **kwds) -> class

    Internal helper function used by the class statement.

这个功能有什么作用？如果它是内部的,为什么必须在内置？这个type(name, bases, dict)功能有什么区别？

python中可用的最短哈希(文件名可用形式,如hexdigest)是什么？我的应用程序想要保存某些对象的缓存文件.对象必须具有唯一的repr(),因此它们用于"种子"文件名.我想为每个对象生成一个可能唯一的文件名(不是那么多).它们不应该发生冲突,但是如果它们发生了我的应用程序将只是缺少该对象的缓存(并且必须重新索引该对象的数据,这是应用程序的一个小成本).

因此,如果存在一个冲突,我们会丢失一个缓存文件,但是收集的缓存所有对象的节省使得应用程序启动速度更快,因此无关紧要.

现在我实际上正在使用abs(hash(repr(obj))); 那是对的,字符串哈希!还没有找到任何碰撞,但我希望有更好的哈希函数.hashlib.md5在python库中可用,但如果放入文件名,则hexdigest非常长.替代方案,具有合理的抗冲击性？

编辑:用例是这样的:数据加载器获取数据携带对象的新实例.独特的类型有独特的repr.因此,如果存在缓存文件hash(repr(obj)),我将取消该缓存文件并将obj替换为unpickled对象.如果发生碰撞并且缓存是假匹配,我注意到.因此,如果我们没有缓存或具有错误匹配,我改为初始化obj(重新加载其数据).

结论(？)

strpython中的哈希可能已经足够好了,我只担心它的碰撞阻力.但是如果我可以2**16用它来散列对象,那就足够了.

我发现如何采用十六进制哈希(来自任何哈希源)并使用base64紧凑地存储它:

# 'h' is a string of hex digits 
bytes = "".join(chr(int(h[i:i+2], 16)) for i in xrange(0, len(h), 2))
hashstr = base64.urlsafe_b64encode(bytes).rstrip("=")

我的应用程序创建自定义URI(或URL？)来标识对象并解决它们.问题是Python的urlparse模块拒绝解析未知的URL方案,就像解析http一样.

如果我不调整urlparse的uses_*列表,我得到这个:

>>> urlparse.urlparse("qqqq://base/id#hint")
('qqqq', '', '//base/id#hint', '', '', '')
>>> urlparse.urlparse("http://base/id#hint")
('http', 'base', '/id', '', '', 'hint')

这就是我的工作,我想知道是否有更好的方法:

import urlparse

SCHEME = "qqqq"

# One would hope that there was a better way to do this
urlparse.uses_netloc.append(SCHEME)
urlparse.uses_fragment.append(SCHEME)

为什么没有更好的方法来做到这一点？

我有一个实现增量搜索的应用程序.我有一个匹配的unicode字符串目录,并将它们与给定的"key"字符串匹配; 如果目录字符串按顺序包含键中的所有字符,则它是"命中",如果目录字符串中的关键字符集群,则排序更好.

无论如何,这工作正常,并完全匹配的Unicode,让"OST"将匹配" OST blocket"或"R OST "或"R ö d ST恩".

无论如何,现在我想实现折叠,因为在某些情况下,区分诸如"á"或"é"的目录字符和关键字符"a"或"e"是没有用的.

例如:"Ole"应匹配"Olé"

我如何在Python中最好地实现这个unicode-folding matcher？效率非常重要,因为我必须将数千个目录字符串与短的给定键匹配.

它不必将其变成ascii; 实际上,算法的输出字符串可以是unicode.留下一个角色比剥离它更好.

我不知道接受哪个答案,因为我使用了两者兼而有之.采用NKFD分解并删除组合标记几乎可以完成,我只添加了一些自定义音译.这是现在看起来的模块:(警告,包含内联的unicode字符,因为编辑这种方式更好.)

# -*- encoding: UTF-8 -*-

import unicodedata
from unicodedata import normalize, category

def _folditems():
    _folding_table = {
        # general non-decomposing characters
        # FIXME: This is not complete
        u"?" : u"l",
        u"œ" : u"oe",
        u"ð" : u"d",
        u"þ" : u"th",
        u"ß" : u"ss",
        # germano-scandinavic canonical transliterations
        u"ü" : u"ue",
        u"å" : u"aa",
        u"ä" : u"ae",
        u"æ" : u"ae",
        u"ö" : u"oe",
        u"ø" …

OBJ-C(我没有使用过很长一段时间)有一种叫类扩展类.使用新方法声明一个类别并将其编译到您的程序中,该类的所有实例突然拥有新方法.

Python有mixin的可能性,我使用,但mixin必须从程序的底部使用:类必须自己声明它.

预见的类别用例:假设您有一个大的类层次结构,描述了与数据交互的不同方式,声明了获取不同属性的多态方式.现在,类别可以通过在一个位置实现访问这些方法的便捷界面来帮助这些描述类的使用者.(例如,类别方法可以尝试两种不同的方法并返回第一个定义的(非None)返回值.)

有什么办法在Python中做到这一点？

说明性代码

我希望这能澄清我的意思.关键是类别就像一个聚合接口,AppObj的使用者可以在其代码中进行更改.

class AppObj (object):
  """This is the top of a big hierarchy of subclasses that describe different data"""
  def get_resource_name(self):
    pass
  def get_resource_location(self):
    pass

# dreaming up class decorator syntax
@category(AppObj)
class AppObjCategory (object):
  """this is a category on AppObj, not a subclass"""
  def get_resource(self):
    name = self.get_resource_name()
    if name:
      return library.load_resource_name(name)
    else:
      return library.load_resource(self.get_resource_location())

在Java中有一个非常冗长和严格的背景,我发现能够改变Python对象,以便为它们提供除了提供给构造函数之外的字段真的"丑陋".

试图让自己习惯于Pythonic的思维方式,我想知道我应该如何构建我的对象.

我的直觉是必须在施工时传递字段,例如:

def __init__(self, foo, bar, baz=None):
    self.foo = foo
    self.bar = bar
    self.baz = baz

但是,这可能会变得过于冗长和令人困惑,许多领域都要通过.为了克服这个问题,我假设最好的方法是将一个字典传递给构造函数,从中提取字段:

def __init__(self, field_map):
    self.foo = field_map["foo"]
    self.bar = field_map["bar"]
    self.baz = field_map["baz"] if baz in field_map else None

我能想到的另一种机制是在其他地方添加字段,例如:

class Blah(object):

    def __init__(self):
        pass

...

blah = Blah()
blah.foo = var1

但随着那种感觉这样太松了我.

(我想我脑子里的问题是我如何处理Python中的接口 ......)

所以,重申一个问题:我应该如何在Python中构建我的对象？是否有公认的惯例？

我正在使用pygtk通过框架编写程序.主程序做了以下事情:

1. 创建一个监视程序线程来监视某些资源
2. 创建一个客户端以从套接字接收数据
3. 呼叫 gobject.Mainloop()

但似乎在我的程序进入Mainloop后,监视程序线程也将无法运行.

我的解决方法是使用gobject.timeout_add运行监视器的东西.

但为什么创建另一个线程不起作用？

这是我的代码:

import gobject
import time
from threading import Thread

class MonitorThread(Thread):

    def __init__(self):
        Thread.__init__(self)

    def run(self):
        print "Watchdog running..."
        time.sleep(10)

def main():

    mainloop = gobject.MainLoop(is_running=True)

    def quit():
        mainloop.quit()

    def sigterm_cb():
        gobject.idle_add(quit)


    t = MonitorThread()
    t.start()

    print "Enter mainloop..."

    while mainloop.is_running():
        try:
            mainloop.run()
        except KeyboardInterrupt:
            quit()

if __name__ == '__main__':

    main()

程序只输出"Watchdog running ...输入mainloop ..",然后什么都没有.进入mainloop后似乎线程永远不会运行.