关于编码风格存在争议，关于最简单的事情。没有权利，但可以理解。我想从那些熟悉规则的人那里知道。PEP8 对此有何评论？怎么会好？
# Первый вариант через переменную. Такую переменную можно логировать, в пичарме.
def my_func(x):
n = x + 2
return n
# Второй вариант, без лишних переменных. Меньше строк.
def my_func_two(x):
return x + 2
from abc import ABCMeta, abstractmethod
class AbstractObject(metaclass=ABCMeta):
pass
class BObject(AbstractObject):
pass
class CObject(AbstractObject):
pass
class A(metaclass=ABCMeta):
def restore_object(self) -> "AbstractObject":
a = self.create_object()
# другие действия
return a
@abstractmethod
def create_object(self) -> "AbstractObject":
pass
class B(A):
def create_object(self):
return BObject()
class C(A):
def create_object(self):
return CObject()
b_manager = B()
c_manager = C()
one_object: "BObject" = b_manager.restore_object() # здесь ошибка типа
two_object: "CObject" = c_manager.restore_object() # Expected type 'BObject', got 'AbstractObject' instead
调用方法“restore_object”时，无法指定所需的类型。在其他一些语言中，可以使用与我指出的大致相同的语法从抽象中细化返回类型。如何在 Python 中解决这个问题？
好日子。由于 DRF 抛出与地理框架相关的错误，无法将 django 从 1.11 版升级到 2.0 版及更高版本：
File "D:\python36\lib\site-packages\rest_framework_gis\apps.py", line 13, in ready
from .fields import GeometryField
File "D:\python36\lib\site-packages\rest_framework_gis\fields.py", line 5, in <module>
from django.contrib.gis.gdal import OGRException
ImportError: cannot import name 'OGRException'
在 django 2.0 版本描述中，它说异常OGRException被替换为GDALException，但出于某种原因，所有版本中的 DRF 都尝试导入它。
我会很感激任何提示。
好日子。
我正在尝试使用由connection.makefile("r").
我希望收到一份包含指定职位数量的列表。
s = b"string\r\nstring\r\nstring\r\nstring\r\nstring\r\nstring\r\nstring\r\n" # семь строк
# отправляю строку на сервер
# на сервере
file_read = connection.makefile("r", newline="\r\n")
lines = file_read.readlines(6) # здесь получаю: ["string\r\n"]
# хотя ожидаю такой список ["string", "string", "string", ...]
请告诉我我做错了什么，或者我不明白什么。我在网上没有找到答案。
class AModel(models.Model)
some = CharField()
class BModel(models.Model)
some = CharField()
a_model = models.ForeignKey(AModel, models.CASCADE, related_name="b_models")
class CModel(models.Model)
some = CharField()
a_model = models.ForeignKey(AModel, models.CASCADE, related_name="c_models")
# Вот теперь мне нужно найти все AModel, у которых
a_model.b_models.all().exists() == False and
a_model.c_models.all().exists() == False
也就是说，这些模型尚未绑定到的那些。
如何提出这样的要求？谢谢你。
with decimal.localcontext() as ctx:
ctx.prec = 7
a = decimal.Decimal(15100000)
b = decimal.Decimal(-2125.234523452345)
c = a + b # Decimal('1.509787E+7')
print(float(c)) # 15097870.0
在最后一行中，您可以看到他没有四舍五入到小数点后七位，而是一般在小数点后七位。
我勒个去？
如何使它精确到小数点后七位？
好日子。我找不到如何通过 websocket 以 json 格式组织数据交换。请告诉我。
我想出了如何连接 websocket，但我找不到如何处理标准 json 格式的传入消息。
我正在使用python 3.6。
它采用了“Single”，它将按 id 以单数形式存储实例，但遇到了困难。实例没有通过类型检查，尽管它们看起来应该是这样。
也就是说，该方法__call__返回原始类的一个实例。这也可以通过检查功能来确认type。
但显然，我什么都不知道，因为我不想上课和isinstance争论。CarTree
使用装饰器编写单例以使其通过类型检查的正确方法是什么？
class Singleton:
def __init__(self, cls):
self.__cls = cls
self.__instances = []
print("был вызван конструктор")
def __call__(self, idt, *args, **kwargs):
for instance in self.__instances:
if instance.idt == idt:
return instance
else:
inst = self.__cls(idt=idt, *args, **kwargs)
self.__instances.append(inst)
return inst
@Singleton
class Car:
def __init__(self, *, idt: int):
self.idt = idt
def __str__(self):
return f"Car {self.idt}."
@Singleton
class Tree:
def __init__(self, *, idt: int):
self.idt = idt
def __str__(self):
return f"Tree {self.idt}."
class Paper:
def __init__(self, *, idt: int):
self.idt = idt
def __str__(self):
return f"Tree {self.idt}."
car = Car(idt=1)
tree = Tree(idt=1)
print(car, tree)
car2 = Car(idt=2)
car3 = Car(idt=1)
tree2 = Tree(idt=2)
tree3 = Tree(idt=3)
car4 = Car(idt=1)
paper = Paper(idt=1)
print(car, car2, car3)
print("Проверка типов: ", type(car), type(tree))
print(type(paper), isinstance(paper, Paper))
print("Проверка на синглтон: ", isinstance(car, Singleton))
print(isinstance(tree, Tree))
print(isinstance(car, Car))
我尝试根据 SOLID 规则培养设计技能。
有一个大的逻辑相关类代表一个真实世界的对象。假设一个类中有大约 40 个方法来表示该对象的行为。
大概有数百种方法。如果它们在逻辑上连接，那么这是允许的，据我所知。
但是使用它们很不方便。我希望类别可以更方便地使用课程。
用三种不同的方式写了一个类似的课程。根据建议，我尝试使用组合而不是继承。
汽车——最简单的，但如果有四十或一百种方法，那就不方便了，过一段时间就很难弄清楚了。
Car2 -是一个组合，但违反了 SOLID 规则的“Demeter 法则”，因为客户不仅知道 Car2，还知道他的朋友。
Car3 -不违反任何东西，封装了每个类，但是方法的数量和第一个版本一样，不是很方便。
在我看来，第二个版本是最方便的。第三个在方法的数量上与第一个没有区别，但似乎是最正确的一个。
如果有人明白，指出错误。我采取了正确的方法吗？哪种方法最合适？
class Car:
def __init__(self):
self._speed = 0
self._name = "Car"
def __str__(self):
return self.name
@property
def speed(self):
return self._speed
@property
def name(self):
return self._name
def turn_left(self): pass
def turn_right(self): pass
def accelerate(self): pass
def brake(self): pass
def windscreen_wiper_on(self): pass
def windscreen_wiper_of(self): pass
# -----------------------------------------------------------------------
class Car2():
def __init__(self):
self._speed = 0
self._name = "Car"
self._stering_wheel = SteringWheel(self)
self._gas_pedal = GasPedal(self)
self._windscreen_wiper = WindscreenWiper(self)
def __str__(self):
return self.name
@property
def speed(self):
return self._speed
@speed.setter
def speed(self, value):
self._speed = value
print("Новая скорость машины:", self._speed)
@property
def name(self):
return self._name
@property
def stering_wheel(self):
return self._stering_wheel
@property
def gas_pedal(self):
return self._gas_pedal
@property
def windscreen_wiper(self):
return self._windscreen_wiper
# -----------------------------------------------------------------------
class Car3:
def __init__(self):
self._speed = 0
self._name = "Car"
self._stering_wheel = SteringWheel(self)
self._gas_pedal = GasPedal(self)
self._windscreen_wiper = WindscreenWiper(self)
def __str__(self):
return self.name
@property
def speed(self):
return self._speed
@speed.setter
def speed(self, value):
self._speed = value
print("Новая скорость машины:", self._speed)
def turn_left(self):
self._stering_wheel.turn_left()
def turn_right(self):
self._stering_wheel.turn_right()
def accelerate(self):
car.gas_pedal.press()
def brake(self):
car.gas_pedal.depress()
def windscreen_wiper_on(self):
car.windscreen_wiper.on()
def windscreen_wiper_of(self):
car.windscreen_wiper.off()
# ---------------------------- Компоненты машины ------------------------------
class SteringWheel:
def __init__(self, car: Car):
self._car = car
def rotate_left(self):
print(self._car.name, "повернула влево")
def rotate_right(self):
print(self._car.name, "повернула вправо")
class GasPedal:
def __init__(self, car: Car):
self._car = car
def press(self):
self._car.speed += 1
def depress(self):
self._car.speed -= 1
class WindscreenWiper:
def __init__(self, car: Car):
self._car = car
def on(self):
print("Дворники", self._car.name, "очищают окно.")
def off(self):
print("Дворники", self._car.name, "выключились.")
# ---------------------------------------------------------------------------
def main():
car = Car2()
car.gas_pedal.press()
car.gas_pedal.press()
car.gas_pedal.depress()
car.windscreen_wiper.on()
car.windscreen_wiper.off()
car.stering_wheel.rotate_left()
main()
典型情况。例如，让我们以同样的典型汽车为例。
汽车有轮子（包含），汽车给轮子旋转（影响），轮子移动汽车（影响）。
如何根据 OOP（可能是 GRASP 或 SOLID）正确组合这样的组合？在这里使用什么设计模式？
我什么都赶不上。不断有这个困难。
有这样的模型。您需要编写一个查询来查找没有required_models. 也就是说，请求my_model.required_models.all()将返回空的那些query_set
class MyModel(models.Model):
name = models.CharField(max_length=40)
text = models.TextField(max_length=1000, default="", blank=True)
required_models = models.ManyToManyField(
"self", related_name="released_models", blank=True, symmetrical=False)
如果编写一个中间模型，那就更容易了。
class ThroughModel(models.Model):
required_model = models.ForeignKey(MyModel, null=True)
released_model = models.ForeignKey(MyModel, null=True)
那么请求将类似于：
TroughModel.objects.filter(required_model=None)
然后从他们那里已经得到了必要的MyModel
通过 many_to_many 帮助编译。我自己什么都想不出来。
也就是说，例如，代码是为自己执行的，这应该改变几个不同的模型。肯定是不同的型号。比如五个。
假设他换了两个模型，异常跳了出来。因此，三个模型仍未完成。
如何回滚前两个模型中的更改以保持计算的完整性？
在所有方法中，到目前为止，我只看到了 dzhang 交易。但是据我所知，事务向数据库发送了许多请求，因此在此期间没有其他人可以进行更改。
还是在 Dzhang 的交易方式不同？文档说他们减慢了程序，最好在事务中包装尽可能少的部分。
最好的方法是什么？有没有办法使用 Python 异常回滚？
我一直在修补这个话题。得出了一些结论。我发现在sqlalchemy中，其实也使用了同样的机制，只是在django中，和sqlalchemy不同的是，autocommit最初是开启的。事务隔离的级别是在数据库本身中配置的。一般来说，使用 django 使用事务是最可靠的选择。是的，而且耗时最少。您只需要最初以编码风格实现它们。然后感觉会很好。它们将以最优化的方式使用。
为了安全起见，我只想在闪存驱动器上复制一份，以免将代码存储在一个地方。
这里不需要 Github 或 bitbucket，因为这项工作不是团队合作的。在我看来，在闪存驱动器上模拟远程存储库会更方便。
如果可能，它是如何实现的？
谢谢你。
介绍性的。有一个固定大小的块。您需要在块中放置不同数量的相同大小的图像。如果图像很少，并且它们被放置在一个块中，那么它们应该彼此跟随（就像在常规的内联块中一样）。
但如果更多，那么它们应该均匀地相互碰撞，就像压实一样（折叠成一堆，像卡片一样），并保持它们原来的大小。
是否可以仅使用 css 来做到这一点？
内联块时的示例。
一个例子当没有足够的空间，有必要强加。
有一个 orm 容器类，它在其实例中存储一些数据集。
例如：
class КлассКонтейнер(ОрмКласс):
название: str
сила: int
здоровье: int
class Существо(ОрмКласс):
исходник: КлассКонтейнер
текущее_здоровье: int
ещё_не_гоблин = КлассКонтейнер(название="Гоблин", сила=5, здоровье=5)
гоблин = Существо(исходник=ещё_не_гоблин)
гоблин_2 = Существо(исходник=ещё_не_гоблин)
这些类通常叫什么？据我了解，这不是预制件。任何地精都可以是预制件。
这是一个看似合乎逻辑的选择：
class MyDate extends Date {
constructor(dateTimeStr: string) {
super(dateTimeStr);
console.log(this, typeof(this));
this.setTime(this.getTime() + 1000);
}
}
但事实证明，显然，因为它作为函数super调用，而不是作为类调用，所以它返回一个字符串。因此，它变成了一个字符串。DateDate()new DateDatethis
告诉我您通常如何延长日期。
该主题的标题并没有完全说明问题的本质，但我不知道如何更好地表述它。
假设我的树既能长樱桃又能长甜樱桃。但由于这是两个不同的类，它们的行为也会有所不同。假设他们有不同的方法。但是尽管这些类有不同的方法，它们仍然需要被调用。
OOP，我理解得很好，模式也是。
我想听听如何按照 OOP 的原则用静态类型的语言最好地解决此类问题。
abstract class АЯгода {
}
class Вишня extends АЯгода {
разбрызгиваетСвойСок() {}
}
class Черешня extends АЯгода {
выстреливаетКосточкой() {}
}
class МоёДерево {
private _ягода: АЯгода;
constructor(ягода: АЯгода) {
this._ягода = ягода;
}
get ягода(): АЯгода {
return this._ягода
}
}
let дерево = new МоёДерево(new Вишня());
if (дерево.ягода instanceof Вишня) {
дерево.ягода.разбрызгиваетСвойСок(); # Здесь всегда будет ошибка.
}
我正在使用 python-3.6.1
我测试了继承中的属性，但结果发现 setter 不起作用。
class MyClass:
def __init__(self, number):
сам.__number = number
@property
def number(self):
return сам.__number
@number.setter
def number(self, new: int):
сам.__number = new
class MyClass2(MyClass):
@property
def number(self):
return super().number + 1
@number.setter
def number(self, new: int):
super().number = new
class MyClass3(MyClass2):
@property
def number(self):
return super().number + 1
@number.setter
def number(self, new: int):
super().number = new
i = MyClass3(0) # ок
print(i.number) # -> 2 То есть в каждом геттере добавлено по единичке.
i.number = 10 # AttributeError: 'super' object has no attribute 'number'
理论上，二传手应该工作。
为什么会发生这种情况 - getter 起作用，但 setter 不起作用？
是否值得在 python 中使用属性，因为它们不能被改变？在哪些情况下？
谢谢你。
您需要检查以下行：
我用的是python，它用的正则表达式是什么方言，我不知道，我到现在才知道有方言。
是否可以使用单个表达式构建？谢谢你。