小编Sin*_*ion的帖子

在python中我们可以说:

if foo < bar < baz:
    do something.

同样,我们可以重载比较运算符,如:

class Bar:
    def __lt__(self, other):
        do something else

但实际上调用了那些区间比较的操作数类型的哪些方法呢？是以上相当于

if foo.__lt__(bar) and bar.__lt__(baz):
    do something.

编辑:re S.Lott,这里有一些输出有助于说明实际发生的事情.

>>> class Bar:
    def __init__(self, name):
        self.name = name
        print('__init__', self.name)
    def __lt__(self, other):
        print('__lt__', self.name, other.name)
        return self.name < other.name

>>> Bar('a') < Bar('b') < Bar('c')
('__init__', 'a')
('__init__', 'b')
('__lt__', 'a', 'b')
('__init__', 'c')
('__lt__', 'b', 'c')
True
>>> Bar('b') < Bar('a') < Bar('c')
('__init__', 'b')
('__init__', 'a')
('__lt__', 'b', 'a') …

我只是学习如何使用SQLAlchemy.我正在尝试执行以下操作,但将标题和链接存储在两个单独的表中:

temp = Submissions(title=u'Facebook Homepage', link=u'http://facebook.com')
session.add(temp)
session.flush()
transaction.commit()

通过:

class Links(Base):
    __tablename__ = 'links'
    id = Column(Integer, primary_key=True)
    link = Column(Text)
    created = Column(TIMESTAMP(), default=datetime.now())

    def __init__(self, link):
        self.link = link

class Submissions(Base):
    __tablename__ = 'submissions'
    id = Column(Integer, primary_key=True)
    created = Column(TIMESTAMP(), default=datetime.now())
    title = Column(Text)
    link_id = Column(Integer, ForeignKey('links.id'))
    link = relation(Links)

    def __init__(self, title, link):  
        self.title = title
        self.link = link

但是,我总是得到这个错误:

AttributeError: 'unicode' object has no attribute '_sa_instance_state'

到底是怎么回事？有没有更好的方法来编码？

借用文档中的__contains__文档

print set.__contains__.__doc__
x.__contains__(y) <==> y in x.

这似乎适用于原始对象,如int,basestring等.但对于定义__ne__和__eq__方法的用户定义对象,我得到意外的行为.这是一个示例代码:

class CA(object):
  def __init__(self,name):
    self.name = name

  def __eq__(self,other):
    if self.name == other.name:
      return True
    return False

  def __ne__(self,other):
    return not self.__eq__(other)

obj1 = CA('hello')
obj2 = CA('hello')

theList = [obj1,]
theSet = set(theList)

# Test 1: list
print (obj2 in theList)  # return True

# Test 2: set weird
print (obj2 in theSet)  # return False  unexpected

# Test 3: iterating over the set …

嗨,我是非常新的ember js.我在模板中的链接到动作上传递动作参数(id)但我没有在我的控制器中获取值.

我的模板代码如下:

index.html的:

             <script type="text/x-handlebars" data-template-name="search">

             {{#each model.results}}

             // here i pass id value along with action

             {{#link-to 'profile' id action="profileinfo"}}

             </script>

app.js:

          App.SearchController = Ember.ObjectController.extend({

             id: '',

             actions:{
               profileinfo: function(id){

                // Here i access id value like this
               console.log(id);
               var id = this.get('id');})  

当我点击链接动作转到Searchcontroller,但我得到id值为空.我在堆栈溢出中遵循一些解决方案,但不幸的是我没有得到任何东西.请提供一些解决方案

我对一个python库感兴趣,它允许符号操作符号,并且可以是任意类型的未知数.

这是我的代码要这样写:

>>> myexpression = symbol("foo") == "bar"
>>> print myexpression
foo == "bar"
>>> print myexpression(foo="quux")
False
>>> myexpression.or_(True)
True

或者粗略估计一下.它实际上甚至不需要那么聪明,我很高兴不得不调用许多额外的内省方法来获得类似上面的东西(例如,即使逻辑重言式没有直接简化)

我的第一直觉是观察同情,但似乎图书馆强烈假设象征变量必须是数字; 我想至少对序列和集合进行操作:

>>> myexpression = sympy.Eq(sympy.Symbol("foo"), 5)
>>> myexpression
foo == 5
>>> myexpression = sympy.Eq(sympy.Symbol("foo"), "bar")
Traceback (most recent call last):
  ...
sympy.core.sympify.SympifyError: SympifyError: 'bar'

有没有办法让人们了解非数字变量或其他可以做类似事情的库？

我一直在使用brew安装运行python.我使用安装工具安装了mysql_python egg(根据mysql_python说明进行标准安装),并将其安装到/usr/local/lib/python2.7/site-packages/.已处理的依赖项等

然后我去运行python控制台.我可以导入其他东西(例如import django; print django.VERSION工作)但是当我导入MySQLdb时,我收到以下错误:

Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "/usr/local/Cellar/python/2.7.1/lib/python2.7/site-packages/MySQL_python-1.2.3-py2.7-macosx-10.4-x86_64.egg/MySQLdb/__init__.py", line 19, in <module>
    import _mysql
ImportError: dlopen(/usr/local/Cellar/python/2.7.1/lib/python2.7/site-packages/MySQL_python-1.2.3-py2.7-macosx-10.4-x86_64.egg/_mysql.so, 2): Library not loaded: libmysqlclient.18.dylib
  Referenced from: /usr/local/Cellar/python/2.7.1/lib/python2.7/site-packages/MySQL_python-1.2.3-py2.7-macosx-10.4-x86_64.egg/_mysql.so
  Reason: image not found

任何见解？非常感谢.

我正在开发一个http客户端,我想在需要一些时间才能完成的请求上测试它.我当然可以提出一个python脚本来满足我的需求,例如:

def slow_server(environ, start_response):
    with getSomeFile(environ) as file_to_serve:
        block = file_to_serve.read(1024);
        while block:
            yield block
            time.sleep(1.0)
            block = file_to_serve.read(1024);

但这感觉就像其他人已经遇到的问题.是否有一种简单的方法来提供具有荒谬的低带宽上限的静态文件,缺少像apache或nginx这样的满级服务器.

我正在研究linux,到目前为止我测试的方式是python -m SimpleHTTPServer 8000在一个充满文件的目录中.我同样对另一个简单的命令行服务器感兴趣,或者在tcp端口8000上使用一个或几个iptables命令进行带宽限制(或任何可行的方法).

我广泛使用sqlalchemy中的ORM设施,因此在许多情况下,我已经从数据库加载了数据,并且想要检查条件或对已经加载的python对象执行计算; 我还希望/需要做更多面向批处理的任务,通过对数据库执行sql(而不是根本不加载数据)可以更好地表达这些任务.我想使用相同的代码来表达两种用途的相同计算,这样我就不必向后弯曲数据库连接或者每次计算两次(一次在常规python中,再次作为查询)并运行他们不同意的风险.

假设我有:

from sqlalchemy import Integer, Column
from sqlalchemy.ext.declarative import declarative_base

Base = declarative_base()


class Foo(Base):
    __tablename__ = 'foo'
    id = Column(Integer, primary_key=True)
    bar = Column(Integer)

bool_clause = Foo.bar > 10
int_clause = Foo.bar + 10

a_foo = Foo(bar=5)

有办法得到

>>> something(bool_clause, a_foo)
False
>>> something(int_clause, a_foo)
15

没有先坚持a_foo到数据库然后执行查询？我特别想要一种表达子句的方法,以便它也可以在数据库查询的上下文中使用,但是如果没有一个,它仍然有用.

一种选择是将条款更改为函数:

bool_clause = lambda foo=Foo: foo.bar > 10
int_clause = lambda foo=Foo: foo.bar + 10

>>> bool_clause(a_foo)
False
>>> int_clause(a_foo)
15

但我发现这比表达条款的原始方式更不易读.

我想要一些关于如何测试一些可以阻塞的对象,等待另一个参与者的想法.要测试的特定单元是参与者之间的通道.参与者本身是用于测试目的的模拟装置.

很高兴验证参与者在预期时会发生死锁,但这对我来说并不是非常重要,因为在死锁之后发生的事情可以合理地描述为未定义.

更重要的是验证参与者定义的交互不会死锁.

在任何一种情况下,我都不确定最佳测试策略应该是什么.我目前的想法是让测试运行器为每个参与者触发一个线程,休眠一段时间,然后发现子线程是否已经返回.在它们没有及时返回的情况下,假设它们已经死锁,并且安全地终止线程,并且测试失败(或者如果预期死锁则成功).

这感觉有点可能性,因为可能存在各种原因(但不太可能),线程可能需要比预期更长的时间才能完成.有没有其他好方法来解决这个问题？

编辑:我确信测试的稳健性会很好,但我认为我不需要它.我正在考虑三个级别的测试确定性.

• "实际行为已被证明与预期的行为相匹配"不会发生死锁
• "实际行为符合预期行为"N次测试中没有发生死锁
• "实际行为符合预期的行为"N测试在预期的截止日期内完成

第一个当然是一个有价值的测试,但ShiDoiSi的答案说明了这一点的不切实际.第二个明显弱于第一个,但仍然很难; 如何确定进程网络实际上已陷入僵局？我不确定这比第一次更容易证明(可能更难)

最后一个更像我的想法.

我正在根据 SQLAlchemy 实现一种具有Partially Ordered Set数学特征的结构，其中我需要能够一次添加和删除一个边。

在我目前的最佳设计中，我使用了两个邻接表，一个是分配表（大约是哈斯图中的边），因为我需要保留哪些节点对被明确设置为有序，另一个邻接表是传递的关闭第一个，以便我可以有效地查询一个节点是否相对于另一个节点排序。现在，每次在分配邻接列表中添加或删除边时，我都会重新计算传递闭包。

它看起来像这样：

assignment = Table('assignment', metadata,
    Column('parent', Integer, ForeignKey('node.id')),
    Column('child', Integer, ForeignKey('node.id')))

closure = Table('closure', metadata,
    Column('ancestor', Integer, ForeignKey('node.id')),
    Column('descendent', Integer, ForeignKey('node.id')))

class Node(Base):
    __tablename__ = 'node'
    id = Column(Integer, primary_key=True)

    parents = relationship(Node, secondary=assignment,
        backref='children',
        primaryjoin=id == assignment.c.parent,
        secondaryjoin=id == assignment.c.child)

    ancestors = relationship(Node, secondary=closure,
        backref='descendents',
        primaryjoin=id == closure.c.ancestor,
        secondaryjoin=id == closure.c.descendent,
        viewonly=True)

    @classmethod
    def recompute_ancestry(cls.conn):
        conn.execute(closure.delete())
        adjacent_values = conn.execute(assignment.select()).fetchall()
        conn.execute(closure.insert(), floyd_warshall(adjacent_values))

其中floyd_warshall()是同名算法的实现。

这导致我遇到两个问题。首先是它似乎不是很有效，但我不确定我可以使用什么样的算法来代替。

第二个更多是关于Node.recompute_ancestry()每次分配发生时必须显式调用的实用性，并且只有在分配被刷新到会话中并具有适当的连接之后。如果我想查看反映在 ORM …