相关疑难解决方法(0)

我需要在构造函数中返回 Bike 的实例。例如：

class Bike(object):
    def __init__(self,color):
        self.bikeColor = color
        return self #It should return an instance of the class; is this not right?

myBike = Bike("blue")

当我执行上述操作时，出现以下错误：

TypeError: __init__() should return None, not 'Bike'

如果是这种情况，如果只是假设的话，我该如何返回一个实例return None？

可能重复:
Python使用__new__和__init__？

我试图了解如何使用这两种方法.我知道这__new__ 用于创建一个对象,同时__init__进行初始化.但是我不确定在创建对象时会发生什么.

1. 这是否意味着__new__和__init__必须具有相同的参数？

2. 如果我不使用相同的参数会发生什么？

关于为什么python __init__在创建对象后并不总是调用的问题有很多问题.当然,答案可以在文档的摘录中找到:

如果__new__()返回一个实例cls,那么__init__()将调用新实例的方法__init__(self[, ...]),其中self是新实例,其余参数与传递给它的相同__new__().

如果__new__()没有返回实例cls,则__init__()不会调用新实例的方法.

这个的设计原因是什么？

我正在参加在线 MOOC 课程，但我很难弄清楚这一点，甚至无法准确地表达我正在试图弄清楚的内容。问题是要求仅当某个字符串作为参数传入时才创建对象。您可以在这里看到问题的描述：https://docs.google.com/forms/d/1gt4McfP2ZZkI99JFaHIFcP26lddyTREq4pvDnl4tl0w/viewform ?c=0&w=1 具体部分在第三段中。使用“if”作为init的条件是否合法？谢谢。

在Python中,当子类化元组时,__new__使用self作为参数调用该函数.例如,这是PySpark Row类的一个释义版本:

class Row(tuple):
    def __new__(self, args):
        return tuple.__new__(self, args)

但help(tuple)没有显示出self参数__new__:

  __new__(*args, **kwargs) from builtins.type
      Create and return a new object.  See help(type) for accurate signature.

并help(type)说了同样的话:

__new__(*args, **kwargs)
      Create and return a new object.  See help(type) for accurate signature.

那么如何在类定义中self传递？__new__Row

• 是通过*args吗？
• 确实__new__有一些细微之处,其中它的签名可以与情境改变？
• 或者,文档是否有误？

是否有可能查看源代码,tuple.__new__以便我可以自己查看答案？

我的问题不是这个问题的重复,因为在那个问题中,所有的讨论都是指__new__明确拥有self或cls作为第一个参数的方法.我想了解一下

1. 为什么该tuple.__new__方法没有self或 …

我是Python的新手.我在我正在研究的OpenFlow控制器中遇到了Python代码.

class SimpleSwitch(app_manager.RyuApp):
    OFP_VERSIONS = [ofproto_v1_0.OFP_VERSION]

    def __init__(self, *args, **kwargs):
        super(SimpleSwitch, self).__init__(*args, **kwargs)
        self.mac_to_port = {}

我的问题如下.

1. 是__init__类的构造函数吗？

2. 是self一样的C++的this指针？

3. 是否super(SimpleSwitch, self).__init__(*args, **kwargs)意味着为父/超类调用构造函数？

4. 您可以将新成员添加到self作为mac_to_port？或者已经添加了,只是在这里初始化？

我目前正在研究一个简单的基于文本的Python游戏,只是为了练习python和面向对象的编程,但我遇到了这个错误,它告诉我'LargeManaPotion'没有属性'name',当我看到它确实如此,它的声明方式与'SmallManaPotion'完全相同.我假设这是一个愚蠢的错误,我只是在俯视或者什么但是会很感激帮助.此外,当我在player.inventory函数中打印播放器的库存时,程序将打印药水,所以我不确定为什么它在交易功能中不起作用.无论如何,这是相关的代码.提前致谢.

class ManaPotion:
    def __init__(self):
        raise NotImplementedError("Do not create raw ManaPotion objects.")

    def __str__(self):
        return "{} (+{} Mana)".format(self.name, self.mana_value)


class LargeManaPotion(ManaPotion):
    def __init__(self):
        self.name = "Large Mana Potion"
        self.mana_value = 45
        self.value = 40


class SmallManaPotion(ManaPotion):
    def __init__(self):
        self.name = "Small Mana Potion"
        self.mana_value = 15
        self.value = 10

如您所见,它与SmallManaPotion相同.这是导致错误的函数.

class TraderTile(MapTile):
def intro_text(self):
    return "A frail not-quite-human, not-quite-creature squats in the corner " \
           "\nclinking his gold coins together. \nHe looks willing to trade."

def __init__(self, x, y):
    self.trader …

这是一个问题场景:我有一个C++对象,其中包含一个需要在销毁对象之前调用的Cleanup()虚方法.为了做正确的事情,这个Cleanup方法需要访问完全形成的对象(包括子类数据),所以我不能只在我自己的类的析构函数的开头调用Cleanup(),因为当我的类的时候析构函数被调用,析构函数中的任何子类都已经完成,它们可能已经释放了一些需要查看的Cleanup()数据.

显而易见的解决方案是在删除对象之前要求调用代码手动调用我的例程:

theObject->Cleanup();
delete theObject;

但是这个解决方案很脆弱,因为迟早有人(可能是我)会忘记调用Cleanup()并且会发生坏事.

另一个解决方案是拥有一个"holder"对象,它实现了pImpl技术来包装类,并且在删除对象之前让持有者对象的析构函数在对象上调用Cleanup(); 但是这个解决方案也不是100%理想的,因为它使得类与标准C++类的工作方式不同,并且无法在堆栈上或静态地分配对象.

所以问题是,是否有一些聪明的技术(在C++或C++ 11中)可以用来告诉编译器在调用第一个子类析构函数之前自动调用我的对象上的指定(可能是虚拟的)方法？

(想到它,自动调用Init()方法的类似机制 - 就在最后一个子类构造函数完成之后 - 也可能很方便)

我想要滚动我自己的简单对象,可以跟踪变量的单位(也许我会添加其他属性,如公差).这是我到目前为止:

class newVar():
    def __init__(self,value=0.0,units='unknown'):
        self.value=value
        self.units=units

    def __str__(self):
        return str(self.value) + '(' + self.units + ')'

    def __magicmethodIdontknow__(self): 
        return self.value


diameter=newVar(10.0,'m') #define diameter's value and units

print diameter #printing will print value followed by units

#intention is that I can still do ALL operations of the object
#and they will be performed on the self.value inside the object.

B=diameter*2 

因为我没有正确的魔术方法,所以我得到以下输出

10.0(m)
Traceback (most recent call last):
  File "C:\Users\user\workspace\pineCar\src\sandBox.py", line 25, in <module>
     B=diameter*2 
TypeError: unsupported operand type(s) for *: …

我写了一个类，允许我将天数（整数）添加到日期（字符串 %Y-%m-%d）。这个类的对象需要是 JSON 可序列化的。

以整数形式向我的对象添加天数按预期工作。但是 json.dumps(obj) 为我的原始对象返回了太多信息（“2016-03-23 15:57:47.926362”）。为什么 ？我需要如何修改类以获取“2016-03-23”？请参见下面的示例。

代码：

from datetime import datetime, timedelta
import json

class Day(str):
    def __init__(self, _datetime):
        self.day = _datetime

    def __str__(self):
        return self.day.date().isoformat()

    def __repr__(self):
        return "%s" % self.day.date().isoformat()

    def __add__(self, day):
        new_day = self.day + timedelta(days=day)
        return Day(new_day).__str__()

    def __sub__(self, day):
        new_day = self.day - timedelta(days=day)
        return Day(new_day).__str__()


if __name__ == "__main__":
    today = Day(datetime.today())
    print(today)               # 2016-03-23
    print(json.dumps(today))   # "2016-03-23 15:57:47.926362"
    print(today+1)             # 2016-03-24
    print(json.dumps(today+1)) # "2016-03-24"
    print(today-1)             # 2016-03-22 …

所以我试图覆盖__new__并让它作为一个工厂存在来创建派生实例。在阅读了一些关于 SO 的内容后，我的印象是我也应该调用__new__派生实例。

基础事物

class BaseThing:
    def __init(self, name, **kwargs):
        self.name = name

    # methods to be derived

物厂

class Thing(BaseThing):
    def __new__(cls, name, **kwargs):
        if name == 'A':
           return A.__new__(name, **kwargs)
        if name == 'B':
           return B.__new__(name, **kwargs)        

    def __init__(self, *args, **kwargs):
        super().__init__(name, **kwargs)

   # methods to be implemented by concrete class (same as those in base)

一种

class A(BaseThing):
    def __init__(self, name, **kwargs):
       super().__init__(name, **kwargs)

乙

class B(BaseThing):
    def __init__(self, name, **kwargs):
       super().__init__(name, **kwargs) …

在Python 3中，定义子类时，为什么需要用作 的cls第一个参数__new__，而不用作 的self第一个参数__init__？

一个例子：

class MyClass(object):
    def __new__(cls, *args, **kwargs):
        return super(MyClass, cls).__new__(cls, *args, **kwargs) # with `cls`
    def __init__(self, *args, **kwargs):
        return super(MyClass, self).__init__(*args, **kwargs) # without `self`

当我比较这些函数时，我变得更加困惑：

>>> cls = object
>>> self = cls()
>>> cls.__new__ is self.__new__
True
>>> cls.__init__ is self.__init__
False
>>> self.__init__()
>>> cls.__init__()
Traceback (most recent call last): ...

__new__那么，这些结果之间和背后有何差异__init__？哪些方法是绑定的，哪些是免费的？为什么可以打电话self.__init__()却打不通cls.__init__()？cls.__init__方法是在cls其自身中定义还是在其元类中定义？

我有一类想要根据参数以几种方式实例化对象的类。当我将文件路径传递给函数时，__init__它应该从保存为pickle文件的对象中恢复所有参数。有没有什么聪明的方法可以做到，例如self=load(...)