相关疑难解决方法(0)

我正在尝试一些非常基本的Python继承:

import os

class Parent:
    def __init__(self):
        self.text = 'parent'

    def getText(self):
        print self.text

class Child1(Parent):
    def __init__(self):
        self.x = 'x'

class Child2(Parent):
    def __init__(self):
        self.x = 'x'

if __name__ == "__main__": 
    parent = Parent()
    child1 = Child1()
    child2 = Child2()

    parent.getText()
    child1.getText()
    child2.getText()

但我一直在

Child1实例没有属性'text'

如何将变量传递给孩子？(我有Java/C#的背景,没有太多的Python)

我正在尝试将Scrapy XPathSelector和补丁子类化,以支持CSS3选择器.

XPathSelector 定义如下:

class XPathSelector(object_ref):
    __slots__ = ['doc', 'xmlNode', 'expr', '__weakref__']

    def __init__(self, response=None, text=None, node=None, parent=None, expr=None):
        if parent is not None:
            self.doc = parent.doc
        ...

我子类XPathSelector和覆盖__init__:

class CSSSelector(XPathSelector):
    def __init__(self, *args, **kwargs):
        translator = kwargs.get('translator', 'html').lower()

        if 'translator' in kwargs:
            del kwargs['translator']

        super(XPathSelector, self).__init__(*args, **kwargs)

当我尝试使用时CSSSelector,我得到了AttributeError错误doc,xmlNode并且expr.手动添加这些插槽CSSSelector也无济于事.

使用__slot__s 对类进行子类化的正确方法是什么？

我的完整代码在这里:

"""
Extends `XPathSelector` to allow CSS3 selectors via the …

我正在调查python oop风格.我似乎有__init__如下构造方法.我之前没有看到这种风格.为什么要使用双重__init__方法呢？

EX-

class MinimumBalanceAccount(BankAccount):
    def __init__(self, minimum_balance):
        BankAccount.__init__(self)
        self.minimum_balance = minimum_balance

    def withdraw(self, amount):
        if self.balance - amount < self.minimum_balance:
            print 'Sorry, minimum balance must be maintained.'
        else:
            BankAccount.withdraw(self, amount)

我在Python中遇到了难以继承的问题,但我知道它是如何工作的,因为我在Java方面有了较大的经验......为了清楚起见,我在这里搜索了问题以及在线文档,所以我知道这将是在瞬间被称为重复的问题:P

我在Codecademy上的代码传递方式如下:

class Car(object):
    condition = "new"
    def __init__(self, model, color, mpg):
        self.model = model
        self.color = color
        self.mpg   = mpg

    def display_car(self):
        return "This is a %s %s with %s MPG." % (self.color, self.model, self.mpg)

    def drive_car(self):
        self.condition = "used"

class ElectricCar(Car):
    def __init__(self, model, color, mpg, battery_type):
        self.model = model
        self.color = color
        self.mpg   = mpg
        self.battery_type = battery_type

但据我所知,我几乎要定义一个新类......那里的继承是什么？我可以这样做:

class ElectricCar(Car):
    def __init__(self, battery_type):
        self.model = model
        self.color = color
        self.mpg   = mpg
        self.battery_type = battery_type

也许带有关键字的东西 …

我有以下code.py文件:

class Shape:
    def __init__(self, x, y):
        self.x = x
        self.y = y

    def move(self, delta_x, delta_y):
        self.x += delta_x
        self.y += delta_y

class Square(Shape):
    def __init__(self, side=1, x=0, y=0):
        super().__init__(x, y)
        self.side = side

class Circle(Shape):
    def __init__(self, rad=1, x=0, y=0):
        super().__init__(x, y)
        self.radius = rad

我正在Python解释器中运行代码,如下所示:

>>> import code
>>> c = code.Circle(1)

我收到这个错误:

Traceback (most recent call last):<br>
...<br>
File "code.py", line 18, in __init__<br>
super().__init__(x, y)<br>
TypeError: super() takes at least 1 argument (0 given)<br>

我不明白为什么我会收到这个错误.我指定的rad值为1,我会假设因为我没有指定x和y值,所以Circle应该使用默认值x …

我有一个像这样的结构

class A:
    def __init__(self, x):
        self.a=x

class B(A):
    def __init__(self, x):
        self.b=x

class C(A):
    def __init__(self, x):
        self.c=x

class D(B,C):
    def __init__(self, x):
        self.d=x

现在我想扩展__init__这两个B并且C也将调用A(B和C可以用作独立类).此外D应该调用A,B和C(D组合来自B和C的功能,但仍需要运行所有初始化).所有都__init__采用相同的参数.显然A应该只调用一次.

你看到一个简单的方法吗？

我可以ListField无条件限制mongoengie中数据的长度if吗？

我需要这样的东西：

list = db.ListField(IntField(), max_length = 24)

在我的document.

或者我必须在要更新时检查我的列表的长度，如果我的列表长度大于 24，则不要更新它！

我正在学习《面向绝对初学者的 Python 编程》这本书，并决定通过制作自己的游戏来测试我的一些技能。游戏基本上是“不要被飞来的尖刺击中”，我遇到了一个问题。使用此代码运行时：

class Player(games.Sprite):
    """The player that must dodge the spikes."""

    def update(self):
        """Move to the mouse."""
        self.x = games.mouse.x
        self.y = games.mouse.y
        self.check_collide()

    def check_collide(self):
        """Check for a collision with the spikes."""
        for spike in self.overlapping_sprites:
            spike.handle_collide()


def main():


    pig_image = games.load_image("Mr_Pig.png")
    the_pig = Player(image = pig_image,
                     x = games.mouse.x,
                     y = games.mouse.y)
    games.screen.add(the_pig)
    games.mouse.is_visible = False
    games.screen.event_grab = True

    games.screen.mainloop()

main()

我没问题。但是当我想使用“ init ”时，就像在这段代码中一样：

class Player(games.Sprite):
    """The player that must dodge the spikes."""

    def update(self):
        """Move to …

Python新手，很好奇是否有人可以尽可能用通俗易懂的方式解释为什么当你创建子类时，你仍然需要调用父类初始化函数？

假设您有一个这样的父类：

class Pet(object):

    def __init__(self, name, species):
        self.name = name
        self.species = species

    def getName(self):
        return self.name

    def getSpecies(self):
        return self.species

    def __str__(self):
        return "%s is a %s" % (self.name, self.species)

然后我想创建一个名为“Dog”的子类，它显然使用了父类中的一些函数。我的研究告诉我，我需要做这样的事情：

class Dog(Pet):

    def __init__(self, name, chases_cats):
        Pet.__init__(self, name, "Dog")
        self.chases_cats = chases_cats

    def chasesCats(self):
        return self.chases_cats

但是，如果我在定义子类时将父类作为参数传递，为什么我需要调用父类的呢__init__？这不是因为它是子类而自动传递给子类吗？

我确信我在理解中遗漏了一些明显的东西，但它只是不适合我。

我试图了解在Python中实例化子类时创建的对象,例如:

class Car():
    def __init__(self, make, model, year):
        self.make = make
        self.model = model
        self.year = year

class ElectricCar(Car):
     def __init__(self, make, model, year):
          super().__init__(make, model, year)

my_tesla = ElectricCar('tesla', 'model s', 2016)

当我们创建对象my_tesla时,我们通过调用此类的构造函数来实例化类ElectricCar,该类又调用父类的构造函数.怎么会发生？现在我有两个猜测:

1)super()只是对父类的引用,因此我们通过"super().init(make,model,year)"实例化我们的子类来调用父类的构造函数.因此,我们只有一个类PowerCar()的对象.

2)super(),调用父类的构造函数,创建"Car"类的对象,然后我们通过"super().init(make,model,year)" 调用该对象的构造函数.因此,我们有两个对象:Car()类的一个对象和ElectiricCar类的一个对象,在我们的例子中它们是相同的.

哪一个是正确的？如果两者都没有,请解释一下究竟发生了什么:

 super().__init__(make, model, year)