相关疑难解决方法(0)

我有一个类,它获取细节并使用信息填充类,如果它已经id使用details方法实例化了.如果它没有实例化,我希望它改为使用传入的参数details作为id并返回一个新的实例化对象.类似于以下内容:

f = Foo()
f.id = '123'
f.details()

但也允许:

f = Foo.details(id='123')

我可以使用相同的details方法来完成此任务吗？或者我是否需要创建两个单独的方法并制作一个@classmethod？如果我将一个声明为a @classmethod而另一个不声明,它们可以具有相同的名称吗？

我正在尝试设置 pytest，以便每当我运行测试（本地或在 github 操作中）时，环境变量都指向我的测试目录中的文件和位置，而不是根据用户设置的位置。

问题是，如果我ipdb在test_database函数中添加跟踪并打印，夹具更改是可见的os.getenv('DB_URL')，但断言将始终失败，因为DataBase对象始终具有原始的非模拟 url（在 中设置.bash_profile）。

数据库.py

import h5py
import os

class DataBase:

    route = os.environ.get('DB_URL')

    def __init__(self):
        self.connected = False

    def connect(self):
        if not connected:
            self.db = h5py.File(self.route, 'r')
            self.connected = True

测试.py

import os
import pytest

@pytest.fixture(autouse=True)
def mock_test_env(monkeypatch):
    cwd = os.getcwd()
    monkeypatch.setenv('DB_URL', cwd + '/sample_db.hdf5')

测试数据库.py

import pytest
from repo import DataBase

def test_database():
    db = DataBase()
    import ipdb; ipdb.set_trace()
    '''
    os.getenv('DB_URL') returns cwd + '/sample_db.hdf5' …

在某些时候,我遇到了一段这样的代码,用python编写:

class Foo(object):
    @Mystery
    def bar():
       return 5+3
print Foo().bar

哪个打印8.然而我不记得装饰者被称为什么.我在想象事物,还是存在？如果确实存在它叫什么？

我正在尝试使用如下的属性设置器.我在这里关注这个例子: @property装饰器是如何工作的？

class Contact:
    def __init__(self):
        self._funds = 0.00

    @property
    def funds(self):
        return self._funds

    @funds.setter
    def funds(self, value):
        self._funds = value

吸气剂工作正常

>>> contact = Contact()
>>> contact.funds
0.0

但是我错过了关于二传手的事情:

>>> contact.funds(1000.21)

Traceback (most recent call last):
  File "/System/Library/Frameworks/Python.framework/Versions/2.7/lib/python2.7/doctest.py", line 1315, in __run
    compileflags, 1) in test.globs
  File "<doctest __main__.Contact[2]>", line 1, in <module>
    contact.funds(1000.21)
TypeError: 'str' object is not callable

我在这做错了什么？

两者之间有区别吗？

class Example(object):
    def __init__(self, prop):
        self._prop = prop

    def get_prop(self):
        return self._prop

    def set_prop(self, prop):
        self._prop = prop

    prop = property(get_prop, set_prop)

和

class Example2(object):
    def __init__(self, prop):
        self._prop = prop

    @property
    def prop(self):
        return self._prop

    @prop.setter
    def prop(self, prop):
        self._prop = prop

他们似乎做了同样的事情,这不符合python的目标,即只有一种明显的做事方式.有没有首选方式？如果是这样,为什么？

我有类Invoice,其中(简化)具有以下属性:

class Invoice(models.Model)
    number = models.CharField(verbose_name="Number", max_length=16)
    issue_date = models.DateTimeField(verbose_name="Issue date", default=datetime.now)
    total = models.FloatField(verbose_name="Total", blank=True, null=True)

然后,我有InvoiceLine类,它代表发票可以拥有的行/行:

class InvoiceLine(models.Model):
    invoice = models.ForeignKey(Invoice, verbose_name="Invoice")
    description = models.CharField(verbose_name="Description", max_length=64)
    line_total = models.FloatField(verbose_name="Line total")

InvoiceLine是Invoice的内联,我想要实现的是,当在管理员中有人用发票线(一个或多个)保存发票时,计算发票总额.我试图通过覆盖方法保存来做到这一点:

class Invoice(models.Model)
    number = models.CharField(verbose_name="Number", max_length=16)
    issue_date = models.DateTimeField(verbose_name="Issue date", default=datetime.now)
    total = models.FloatField(verbose_name="Total", blank=True, null=True)

    def save(self, *args, **kwargs):
         invoice_lines = InvoiceLine.objects.filter(invoice=self.id)
         self.total = 0
         for line in invoice_lines:
             self.total=self.total+line.line_total
         super(Invoice, self).save(*args, **kwargs)

问题是,当我在InvoiceLine中添加元素时,第一次保存并调用functionsave时,内联(InvoiceLine)中的新元素尚未存储,所以当我这样做时InvoiceLine.objects.filter(invoice=self.id),它们不会被考虑在内.因此,这种方法的唯一方法是节省两次.我也尝试过:

def save(self, *args, **kwargs):
    super(Invoice, self).save(*args, **kwargs)
    invoice_lines = InvoiceLine.objects.filter(invoice=self.pk) …

我有两个模型，想为第二个类创建一个字段，该字段是外部字段和模型中的字段的串联。

我到目前为止的代码是：

class Drug(models.Model):
    drug_name = models.CharField("Drug Name", max_length=200)
    reference_title = models.CharField("Publication Title",max_length=1024)
    pub_date = models.DateField("Pubication Date",'date published')
    pubmed_link = models.CharField("PubMed Link", max_length=300)

class Risk(models.Model):
    drug_link = models.ForeignKey(Drug, on_delete=models.CASCADE)    
    dosage = models.IntegerField(default=0)
    independent_risk = models.DecimalField("Individual Risk", max_digits=4, decimal_places=2)

我想向风险模型添加一个新字段，该字段由药物链接的选定值和剂量的输入值的串联自动填充。

我正在制作一个简单的基于文本的游戏.我的完整代码是150行,所以我将包括我认为相关的内容.如果您需要更多,请告诉我.

问题是这一行:

print("You deal " + str(hero.damage) + " damage to the monster")

根据需要仅返回5而不是5 +级别.

class Hero:

    def __init__(self):
        self.level = 0
        self.damage = 5 + self.level #This is the problem line. Self.level seems to be treated as equal to 0 even when it is higher than 0.
        self.experience = 0
    def level_up(self): #triggered on monster death
        xp_required = 15
        if self.experience >= xp_required:
            self.level += 1
hero = Hero()

我知道hero.level_up()成功是因为:

print(hero.level)

返回适当时正确更新的级别.

我猜是:

self.damage 只计算一次,然后即使在其组成部分发生变化后也存储该值.

要么:

在其中调用 …

我真的不太了解课程，任何帮助都会很棒。

矩形类应具有以下私有数据属性：

\n
• __length
\n
• __width
\n

Rectangle 类应该有一个 __init__方法来创建这些属性并将它们初始化为 1。它还应该有以下方法：

\n

• set_length__length\xe2\x80\x93 该方法为字段赋值

\n

• set_width__width\xe2\x80\x93 该方法为字段赋值

\n

• get_length__length\xe2\x80\x93 该方法返回字段的值

\n

• get_width__width\xe2\x80\x93 该方法返回字段的值

\n

• get_area\xe2\x80\x93 该方法返回 Rectangle 的面积

\n

• __str__\xe2\x80\x93 该方法返回对象\xe2\x80\x99s 状态

\n

\n\n

class Rectangle:\n\n  def __init__(self):\n      self.set_length = 1\n      self.set_width = 1\n      self.get_length = 1\n      self.get_width = 1\n      self.get_area = 1\n\ndef get_area(self):\n    self.get_area = self.get_width * self.get_length\n    return self.get_area\n\n\ndef main():\n\n  my_rect = …

尝试检查两个 jitclass 实例属性的身份时，我发现与普通的 python 类相比，这种行为很奇怪。Numba jitclass 在其自己的实例属性身份检查中返回 False，其中普通 Python 类按预期工作。

import numba

class MyClass(object):
    def __init__(self, x):
        self.x = x

spec = [('x', numba.double)]
@numba.jitclass(spec)
class MyJitClass(object):
    def __init__(self, x):
        self.x = x

a = MyClass(1)
b = MyJitClass(1)

现在检查身份：

>>> a.x is a.x
True
>>> b.x is b.x
False

知道为什么会这样吗？我应该如何检查两个 jitclass 属性是否引用了同一个对象？

我是python的新手,目前正在尝试学习属性.

class Car(object):
    def set_speed(self, speed):
        self._speed = speed
        print("set speed to {}".format(self.speed))


    def get_speed(self):
        return self._speed
        print("the speed is {}".format(self.speed))


    speed = property(fget = get_speed, fset=set_speed)

car1 = Car()
car1.speed = 170
x = car1.speed

我得到的输出是 set speed to 170

这一切都很好,从那以后car1.speed就没有任何意外了.但是,为什么从来没有"The speed is 170"印刷线呢？ car1.speed是以同样的方式被召唤？有什么我不明白的吗？

我知道python中的函数总是返回变量的引用。我很好奇属性的getter方法是否返回深拷贝，或者getter方法仅是形式并返回引用。