TypeError：toString（）缺少1个必需的位置参数：'self'

Question

So I wrote a small project to practice objects:

import random
import os
import sys

class Animal:
    __name = ""
    __height = 0
    __weight = 0
    __sound = 0

    def __init__(self, name, height, weight, sound):
        self.__name = name
        self.__height = height
        self.__weight = weight
        self.__sound = sound


    def set_name(self, name):
        self.__name = name

    def get_name(self):
        return self.__name

    def set_height(self, height):
        self.__height = height

    def get_height(self):
        return self.__height

    def set_weight(self, weight):
        self.__weight = weight

    def get_weight(self):
        return self.__weight

    def set_sound(self, sound):
        self.__sound = sound

    def get_sound(self):
        return self.__sound

    def get_type(self):
        print("animal")

    def toString(self):
        return "{} is {} cm tall and {} kilograms and says {}".format(self.__name,
                                                                     self.__height,
                                                                     self.__weight,
                                                                     self.__sound)

cat = Animal('Whiskers', 33, 7, 'Meow')

print(cat.toString())

class Dog(Animal):
    __owner = ""
    def __init__(self, name, height, weight, sound, owner):
        self.__owner = owner
        super(Dog, self).__init__(name, height, weight, sound)

    def set_owner(self, owner):
        self.__owner = owner

    def get_owner(self):
        return self.__owner

    def get_type(self):
        print("Dog")

    def toString(self):
        return "{} is {} cm tall and {} kilograms and says {}. His owner is {}".format(self.__name,
                                                                                self.__height,
                                                                                self.__weight,
                                                                                self.__sound,
                                                                                self.__owner)

pitbull = Dog('James', 70, 30, 'woef', 'john')
print(Dog.toString())

It outputs

Whiskers is 33 cm tall and 7 kilograms and says Meow

    Traceback (most recent call last):
      File "C:/Users/*****/AppData/Local/Programs/Python/Python36-32/practice object oriented programming.py", line 78, in <module>
        print(Dog.toString())
    TypeError: toString() missing 1 required positional argument: 'self'

why is this? It output the cat correctly even though I didn't define 'self'. Why doesn't it output dog correctly? I have tried multiple things I found here, but I have defined the function and I didn't have to define 'self' with the cat. Any help would be appreciated. Thanks

Answer 1

Here :

pitbull = Dog('James', 70, 30, 'woef', 'john')
print(Dog.toString())

You create a Dog instance named pitbull , but call .toString() on the Dog class, not on the pitbull instance.

Python let's you call instancemethods on the class itself but then you have to pass the instance yourself, ie Dog.toString(pitbull) , else the method's code cannot know on which instance it's supposed to work. Of course the simplest solution is to invoke the method directly on the instance, so Python can automagically pass the instance as first argument .

IOW, I assume you wanted:

pitbull = Dog('James', 70, 30, 'woef', 'john')
print(pitbull.toString())

As a side note: your code is totally unpythonic, and might not always work as expected.:

class Animal:

If you're using Python 2.x, you want class Animal(object) , else most of Python's object model features won't work correctly ( super() calls, computed attributes, metaclasses etc).

    __name = ""
    __height = 0
    __weight = 0
    __sound = 0

Here you define four class attributes. "class attributes" means those attributes belong to the class object itself (Python's classes are objects too), so those attributes are shared by all instances of the class.

Class attributes are perfectly legal and have their use case, but defining what attributes an instance of the class will have is not part of class attributes use cases - this is something you do in the initializer (the __init__() method). Also if the instance defines an attribute by the same name as one of the class attribute (whihc is what you're doing for those four attributes), the instance attribute will shadow the class one when looking up the attribute on an instance.

To make a long story short: those four class attributes are totally useless and possibly confusing.

Also you use the __name notation which invokes a name-mangling scheme , making those names inaccessible (well, not really but you have to use the mangled name) from outside the class, so child classes won't be able to access it (unless using the mangled name, which kind of defeats the whole point).

The convention for "protected" attributes (attributes that are not part of your class public API) is to use a single leading underscore.

    def __init__(self, name, height, weight, sound):
        self.__name = name
        self.__height = height
        self.__weight = weight
        self.__sound = sound

Cf the comments above...

def set_name(self, name):
    self.__name = name

def get_name(self):
    return self.__name

Python is not Java... Nothing wrong about Java, but Python has a strong support for computed attributes, so plain getter/setters pairs (which FWIW make your attributes effectively public) are just plain useless. You can just use public attributes, and turn them into computed ones (using the builtin property type or a custom descriptor) if and when the need arises.

def get_type(self):
    print("animal")

A function named get_SOMETHING is usually expected to actually return something - if it prints something (which is more often than not a bad idea for domain model classes which are not supposed to know anything about the UI layer), you should name it print_SOMETHING (and probably pass the stream on which 'something' is to be printed so it can be used with any stream-like object - file or whatever).

Also you could use the class name here ( type(self).__name__ ) instead of hardcoding anything.

def toString(self):

Nothing prevents you from using Java-ish nameing conventions (except from the fact that quite a few python coders will hate you for this), but this won't make the best use of Python's object model. The equivalent to Java's toString() is __str__(self) and will be automagically invoked by Python when trying to format instances of you class as strings ie:

>>> class Foo(object):
...     def __init__(self, name):
...         self.name = name
...     def __str__(self):
...         return "<{} : {}>".format(type(self).__name__, self.name)
... 
>>> f = Foo("yadda")
>>> str(f)
'<Foo : yadda>'
>>> print "{}".format(f)
<Foo : yadda>

Next is you Dog class:

class Dog(Animal):
    def __init__(self, name, height, weight, sound, owner):
        # ...

Your subclass expects one more argument than it's parent class. This breaks Liskov's substitution principle which states that for a subclass to be a proper subtype of it's parent, any action on the parent class must be done verbatim on the subclass. In your case, you could not use the same code to instanciate indifferently an Animal or a Dog - either Animal would complain about getting one expected extra parameter if instanciated with a owner or Dog would complain about the missing owner argument.

There are two solutions here:

• make owner optional (=> provide a default) for Dog ,

• allow Animal to accept (and by default ignore) any extra keyword argument:

  class Animal(object): def init (self, name, height, weight, sound, **kwargs): # your code here

If you want to be fully liskov-compliant, you'll have to use both solutions together so you can still instanciate a Dog without an owner.

NB : note that Python being dynamically typed, subclassing is mainly for implementation reuse, not for subtyping. You could have two totally unrelated classes (=> not descending from a common base class) yet perfectly compatible wrt/ liskov's principle, and you are of course free to subclass a base class without making your child class a proper subtype of it's parent. But your code snippet being partly about both implementation inheritance and subtyping, I thought I'd better mention this.

To summarize all this, here's a much more pythonic version of your code:

class Animal(object):

    def __init__(self, name, height, weight, sound, **kwargs):
        self.name = name
        self.height = height
        self.weight = weight
        self.sound = sound

    # Here we use a read-only computed attribute
    @property
    def type(self):
        return type(self).__name__


    # Here we use a protected class attribute, 
    # named in ALL_CAPS to denote it's supposed to 
    # be treated as a constant.
    _STR_FMT = "{self.type} {self.name} is {self.height} cm tall and {self.weight} kilograms and says {self.sound}." 

    def __str__(self):
        return self._STR_FMT.format(self=self)


cat = Animal('Whiskers', 33, 7, 'Meow')
print(str(cat))

class Dog(Animal):
    def __init__(self, name, height, weight, sound, owner=None, **kwargs):
        super(Dog, self).__init__(name, height, weight, sound, **kwargs)
        self.owner = owner

    def __str__(self):
        fmt = self._STR_FMT
        if self.owner:
            fmt += " His owner is {self.owner}."
        else:
            fmt += " He has no known owner."

        return fmt.format(self=self)

pitbull = Dog('James', 70, 30, 'woef', 'john')
print("{}".format(pitbull))

Answer 2

1. Use pitbull.toString() instead of Dog.toString()
2. __var is not accessible from the class that inherits
3. use __str__ method rather than toString and print() directly

Full code with fixes

import random
import os
import sys

class Animal:
    _name = ""
    _height = 0
    _weight = 0
    _sound = 0

    def __init__(self, _name, _height, weight, sound):
        self._name = _name
        self._height = _height
        self._weight = weight
        self._sound = sound


    def set__name(self, _name):
        self._name = _name

    def get__name(self):
        return self._name

    def set__height(self, _height):
        self._height = _height

    def get__height(self):
        return self._height

    def set_weight(self, weight):
        self._weight = weight

    def get_weight(self):
        return self._weight

    def set_sound(self, sound):
        self._sound = sound

    def get_sound(self):
        return self._sound

    def get_type(self):
        print("animal")

    def __str__(self):
        return "{} is {} cm tall and {} kilograms and says {}".format(self._name,
                                                                     self._height,
                                                                     self._weight,
                                                                     self._sound)

class Dog(Animal):
    __owner = ""
    def __init__(self, _name, _height, _weight, _sound, owner):
        self.__owner = owner
        Animal.__init__(self, _name,_height, _weight, _sound)

    def set_owner(self, owner):
        self.__owner = owner

    def get_owner(self):
        return self.__owner

    def get_type(self):
        print("Dog")

    def __str__(self):
        return "{} is {} cm tall and {} kilograms and says {}. His owner is {}".format(self._name,
                                                                                self._height,
                                                                                self._weight,
                                                                                self._sound,
                                                                                self.__owner)

pitbull = Dog('James', 70, 30, 'woef', 'John')
cat = Animal('Whiskers', 33, 7, 'Meow')
print(cat)
print(pitbull)