小编Ric*_*eur的帖子

GQL是否易于为了解SQL的人学习？Django/Python怎么样？App Engine是否真的能够轻松扩展？是否有针对"GQL注入"的内置保护？等等...

我很想听到使用app引擎的不那么明显的起伏.

干杯!

在Python中定义True和False的顺序,还是作为实现细节保留？

从控制台,我在True之前看到False排序......但我不知道这是否是我应该依赖的行为.

(我确定有一些关于这个的Python文档,但我找不到它......)

当连接对象被不同线程使用时，cx_Oracle 游标的行为是什么？生成器将如何影响这种行为？具体来说...

编辑：原来的示例函数不正确；生成器由子函数返回，yield未直接在循环中使用。这澄清finally了何时执行（在return执行之后），但仍然没有回答如果另一个线程开始使用创建游标的连接对象，是否可以使用游标。它实际上似乎（至少在 python 2.4 中）try...finally会yield导致语法错误。

def Get()
  conn = pool.get()
  try:
    cursor = conn.cursor()
    cursor.execute("select * from table ...")
    return IterRows(cursor)
  finally:
    pool.put(conn)

def IterRows(cursor):
  for r in cursor:
    yield r

Get()是一个被多个线程调用的函数。连接是通过threaded=False参数创建的。

我在想...

1. cursor如果线程 2 出现并使用相同的连接对象，线程 1 的对象是否仍然可用？如果没有，可能会发生什么？

我看到的行为是 cx_Oracle 中谈论协议错误的异常，然后出现段错误。

我正在编写Queue.Queue的自定义子类,并遇到需要put()在调用自定义时获取队列级锁定的情况.我想重用现有的锁Queue has(Queue.mutex),但不能因为它不是一个RLock.

在源代码(python 2.6)中,它说:

# Override these methods [_put, _get, etc] to implement other queue organizations
# (e.g. stack or priority queue).
# These will only be called with appropriate locks held

但是在线文档没有提到覆盖它们.该模块中的其他Queue实现会覆盖这些.所以,我有点倾向于认为这个_put方法是包私有的,并不是真的打算在Queue模块之外使用.

有谁知道Queue._put在我自己的子类中使用和朋友是多么的犹太人？

在Java中,什么时候可以"逃避"不使用synchronized对多个并发线程进行读/写的变量？

我读到了一些令人惊讶的并发错误:双重检查锁定和散列映射,并且在共享读/写情况下默认情况下始终使用同步,但是,我开始怀疑什么时候不行.

例如,我可以用什么样的一般规则来决定时,它的真正安全的忽略synchronized从这样的方法:

T getFoo() {
  if (this.foo == null) {
    this.foo = createFoo() // createFoo is always thread safe.
  }
  return this.foo;
}

哪里:

• T 可能是原始或任意对象
• createFoo 始终是线程安全的,可以多次调用,但是未指定.
• getFoo() 可以"最终保持一致".

如果T是原始的,那可以int吗？怎么样Integer？像String这样的简单对象呢？等等.

我坚持使用python2.4,所以我不能使用带有生成器的finally子句yield.有什么方法可以解决这个问题吗？

我找不到如何在python 2.4中解决这个限制的任何提及,我不是我想到的解决方法(主要涉及__del__并试图确保它在合理的时间内运行)的忠实粉丝不太吸引人.

有没有人知道send()在递归使用时如何与生成器一起工作？我希望将值传递给当前的生成器,然后可以将其传递给递归生成器......但似乎情况并非如此？一些示例代码:

def Walk(obj):
  recurse = (yield obj)
  if not recurse:
    print 'stop recurse:', recurse
    return

  if isinstance(obj, list):
    print 'is list:', obj
    for item in obj:
      print 'item loop:', item
      walker = Walk(item)
      for x in walker:
        print 'item walk:', x
        recurse = (yield x)
        print 'item walk recurse:', recurse
        walker.send(recurse)

root = ['a', ['b.0', ['b.0.0']]]

walker = Walk(root)
for i, x in enumerate(walker):
  print i, x
  print 'send true'
  walker.send(True)

所需的输出应该是每个级别递归的每个值:

0 ['a', ['b.0', ['b.0.0']]]
1 'a'
2 ['b.0', …

我一直试图想出一种使用列表表达式遍历层次结构的方法,比如链表,但是没有提出任何看似有用的东西.

基本上,我想转换这段代码:

p = self.parent
names = []
while p:
  names.append(p.name)
  p = p.parent
print ".".join(names)

变成单线像:

print ".".join( [o.name for o in <???>] )

但是,我不确定如何以通用的方式进行???部分遍历(如果它甚至可能).我有几个具有相似类型属性的结构,并且不希望为每个结构编写一个屈服函数..parent

编辑:

我不能使用__iter__对象本身的方法,因为它已经用于迭代对象本身包含的值.大多数其他答案,除了liori的,硬编码属性名称,这是我想要避免的.

根据liori的回答,这是我的改编:

import operator
def walk(attr, start):
  if callable(attr):
    getter = attr
  else:
    getter = operator.attrgetter(attr)

  o = getter(start)
  while o:
    yield o
    o = getter(o)

我有代码(type, handler_function)在模块加载时静态注册对,导致这样的字典:

HANDLERS = {
  str: HandleStr,
  int: HandleInt,
  ParentClass: HandleCustomParent,
  ChildClass: HandleCustomChild
  }

def HandleObject(obj):
  for data_type in sorted(HANDLERS.keys(), ???):
    if isinstance(obj, data_type):
      HANDLERS[data_type](obj)

ChildClass从哪里继承ParentClass.问题是,由于它是一个字典,订单没有定义 - 但我如何内省类型对象来找出一个排序键？

生成的顺序应该是超类的子类(首先是大多数特定类型).例如,str之前basestring和ChildClass之前ParentClass.如果类型不相关,那么它们相对于彼此的位置并不重要.