相关疑难解决方法(0)

使用 SQLAlchemy，我发现有时我会错误输入映射到列的属性名称，这会导致很难捕获错误：

class Thing(Base):
    foo = Column(String)


thing = Thing()
thing.bar = "Hello" # a typo, I actually meant thing.foo
assert thing.bar == "Hello" # works here, as thing.bar is a transient attribute created by the assignment above
session.add(thing)
session.commit() # thing.bar is not saved in the database, obviously
...
# much later
thing = session.query(Thing)...one()
assert thing.foo == "Hello" # fails
assert thing.bar == "Hello" # fails, there's no even such attribute

有没有办法配置映射类，以便分配给未映射到 SQLAlchemy 列的任何内容会引发异常？

在Python中，method_descriptor（用简单的英语）是什么？

我遇到了这个错误，但实际上找不到任何信息：

*** TypeError: can't pickle method_descriptor objects

我完全理解在这个例子中传递的是什么self.我对它如何被传递到self内部非常困惑.有人可以帮我理解吗？

class Cars:

    def __init__(self, model, engine, doors):

        self.model = model
        self.engine = engine
        self.doors = doors

tesla = Cars('Model S', 'Electric', 'Four door')
ford = Cars('Mustang', 'v8', 'Two door')

是否有可能在需要时在运行时创建信号？

我在一个函数中做这样的事情：

class WSBaseConnector(QObject)

    def __init__(self) -> None:
        super(QObject, self).__init__()    
        self._orderBookListeners: Dict[str, pyqtSignal[OrderBookData]] = {}

    def registerOrderBookListener(self, market: str, listener: Callable[[OrderBookData], None], loop: AbstractEventLoop) -> None:
            try:
                signal = self._orderBookListeners[market]
            except KeyError:
                signal = pyqtSignal(OrderBookData)
                signal.connect(listener)
                self._orderBookListeners[market] = signal
            else:
                signal.connect(listener)

如您所见，我有一个存储 str、pyqtSignal 对的字典。当我尝试将信号连接到侦听器时，出现错误：

'PyQt5.QtCore.pyqtSignal' object has no attribute 'connect'

在没有类变量的情况下，是否无法在运行时创建 pyqtSignals？

干杯。

假设我们有一个要进行猴子补丁的类以及一些我们想对其进行猴子补丁的可调用对象。

class Foo:
  pass

def bar(*args):
  print(list(map(type, args)))

class Baz:
  def __call__(*args):
    print(list(map(type, args)))
baz = Baz()

def wrapped_baz(*args):
  return baz(*args)

Foo.bar = bar
Foo.baz = baz
Foo.biz = wrapped_baz

Foo().bar()  # [<class '__main__.Foo'>]
Foo().baz()  # [<class '__main__.Baz'>]
Foo().biz()  # [<class '__main__.Baz'>, <class '__main__.Foo'>]

即使baz是可调用的，它也不会绑定到Foo()两个函数bar和的实例wrapped_baz。由于Python是鸭子式语言，因此给定可调用类型在对象机制的行为中起着举足轻重的作用，这似乎很奇怪。

并不是说包装可调用对象不一定是坏方法，还有其他方法可以将可调用对象适当地绑定到Foo实例吗？这是CPython实现的一个怪癖，还是语言规范的一部分描述了观察到的行为？

我问这个是因为我觉得这很令人惊讶——我认为 anamedtuple会有更多的开销。

（背景是我在内存中缓存了一个大的 Django 查询，发现 Django 对象的大小是 的 100 倍.values()。然后我想知道namedtuple这些对象的开销版本是什么，允许我仍然使用.对项目的访问作为属性。较小的是不是我所期望的。）

#!/usr/bin/env python                                                           

from pympler.asizeof import asizeof                                             
from collections import namedtuple                                              

import random                                                                   
import string                                                                   

QTY = 100000                                                                    


class Foz(object):                                                              
    pass                                                                        

dicts = [{'foo': random.randint(0, 10000),                                      
          'bar': ''.join([random.choice(string.ascii_letters + string.digits) for n in xrange(32)]),
          'baz': random.randrange(10000),                                       
          'faz': random.choice([True, False]),                                  
          'foz': Foz()} for _ in range(QTY)]                                    

print "%d dicts: %d" % (len(dicts), asizeof(dicts))                             

# /sf/ask/3074486831/

MyTuple = namedtuple('MyTuple', sorted(dicts[0]))                               

tuples = [MyTuple(**d) for d …

我想知道为什么如果没有定义名称,类的方法不会查看其封闭范围.

def test_scope_function():
    var = 5
    def print_var():
        print(var) # finds var from __test_scope_function__
    print_var()


globalvar = 5
class TestScopeGlobal:
    var = globalvar # finds globalvar from __main__

    @staticmethod
    def print_var():
        print(TestScopeGlobal.var)


class TestScopeClass():
    var = 5

    @staticmethod
    def print_var():
        print(var) # Not finding var, raises NameError

test_scope_function()
TestScopeGlobal.print_var()
TestScopeClass.print_var()

我希望TestScopeClass.print_var()打印5,因为它可以读取classvar的TestScopeClass身体.

为什么会这样？我应该在文档中阅读什么才能了解它.