3

I'm learning OOP in Python and I get stucked with one thing.

I have an example class:

class Animal:

    def __init__(self, name="", hunger=0):
        self.name = name
        self.hunger = hunger

    def eat(self):
        self.hunger += 1

And some objects:

dog = Animal("dog")
cat = Animal("cat")
giraffe = Animal("giraffe")

I would like to use method eat() to change value of hunger in every single one of them at one blow. I have already tried to do something like this:

Animal.eat()

But it doesn't work (there's TypeError, because of missing argument 'self').

Also:

Animal.hunger += 1

Doesn't work (returns AttributeError).

If anyone has any ideas, I would be very grateful!

Improve this question
2
  • Do you want them always to have the same hunger. Or different hungers that get changed by the same number when eating? Commented Dec 1, 2017 at 17:02
  • 2
    You should store the instances in a container, like a list or dict then iterate through them calling their eat methods individually. Commented Dec 1, 2017 at 17:02

6 Answers 6

Reset to default
4

You can maintain a class variable that collects the instances and adjust all of their hungers in eat:

class Animal:
    instances = []

    def __init__(self, name="", hunger=0):
        self.name = name
        self.hunger = hunger
        Animal.instances.append(self)

    def eat(self):
        for i in Animal.instances:
            i.hunger += 1

Semantically, you might want to make it a classmethod, though

    @classmethod
    def eat(cls):
        for i in cls.instances:
            i.hunger += 1

You can still call it on instances if you so wish.

Improve this answer
Sign up to request clarification or add additional context in comments.

Comments

2

@schwobaseggi has the most straightforward answer for what you want to do, but what you want to do seems like it's asking for trouble. You have one class that does two very different things. Animal is an animal that has a name and eats, and it also keeps track of every animal instance and makes all of them eat. Animal is trying to do what individual animals do and also control a group of animals.

It might be better to split this into two different kinds of objects: An animal, and some sort of AnimalGroup like Zoo or Farm or Herd. The AnimalGroup class should be responsible for keeping track of a bunch of instances and make them all do stuff.

class AnimalGroup(object):
    def __init__(self, animal_list):
        self.animals = animal_list[:]  

    def add_animal(self, animal):
        self.animals.append(animal)

    def all_eat(self):
        for animal in self.animals:
            animal.eat()

then

dog = Animal("dog")
cat = Animal("cat")
giraffe = Animal("giraffe")
group = AnimalGroup([dog, cat, giraffe])
group.all_eat()
group.add_animal(Animal("pig"))
group.all_eat()

This separates out the responsibilities of each class and makes things much easier to change later on. You can now have different group behaviors without ever needing to change the animal class. You can have new animal classes that inherit from Animal and you don't need to worry about side effects. for example: class Mammal(Animal) . When I call Mammal.eat, will it update all animals? It might. class variables can be a bit tricky like that. Should it update all animals? No idea. With an AnimalGroup object, you don't need to worry.

Improve this answer

1 Comment

Thank you very much, that's exactly what I was looking for!
1

You actually have to call it on the object itself like this:

cat.eat()
dog.eat()
giraffe.eat()

otherwise it doesn't know which object to actually change. You could store all your Objects in an array and loop over that array to call the function on all of them one after another:

dog = Animal("dog")
cat = Animal("cat")
giraffe = Animal("giraffe")
animals=[dog, cat, giraffe]
for animalType in animals:
    animalType.eat()

now you can do them all at once or one at a time if you want. You will however need to addnew animals to the array after you create them to keep the list up to date:

fish=new Animal("fish")
animals.append(fish)
Improve this answer

Comments

1 
class Animal(object):

    hunger = 0

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


    def eat(self):
        Animal.hunger = Animal.hunger + 1

dog = Animal("dog")
cat = Animal("cat")
giraffe = Animal("giraffe")


dog.eat()

print("Dog's hunger variable is", dog.hunger)
1
dog.eat()

print("Dog's hunger variable is :",dog.hunger)
2

print("Cat's hunger variable is :",cat.hunger)
2

print("Giraffe's hunger variable is :", giraffe.hunger)
2

When eat() is called on a single instance, the hunger variable is updated for all instances!

Improve this answer

Comments

0

If you're wanting to do something on the class you have to declare it as a class variable:

class Animal:
  hunger = 0

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

  @classmethod
  def eat(klass):
    klass.hunger += 1

This way anytime you call Animal.eat() you'll be referencing the class method that modifies your class variable. You can still access the variable from within an Animal class with self.hunger but I would advise against that as it can get confusing coming back and trying to determine what's a class variable and what's a member variable.

Improve this answer

4 Comments

This fails if you do dog.hunger = 0 after dog.eat(). Keep doing dog,eat() and value won't change.
@AmitTripathi That's not a "fail" that's how static vs member variables work. If you do dog.hunger=0 you've just created a member variable on the dog object that overwrites the static variable of the class.
I know but I just pointed out that the line is very thin here. I am not sure why OP is asking for such a requirement but this kind of code I won't ever use.
@AmitTripathi That's your choice but that type of problem comes with the language. Python lets you do almost anything you want but with that flexibility comes some risk. Typically if you don't want people messing with your static variables themselves you have to rely on naming conventions to dissuade them. In C you can just set something to static and everyone else goes "Hand's off!"
-1

To the best of my knowledge (and I really like OOP in python), the only way to do this is to create a new class with that specific attribute a.k.a.

class Animals:
    def __init__(self, animals):
        self.animals = animals
    def all_eat(self):
        for animal in animals:
            animal.eat()

Then what you would have to do is:

dog = Animal("dog")
cat = Animal("cat")
giraffe = Animal("giraffe")
animals = Animals((dog, cat, giraffe))
animals.all_eat()

The reason for this is that python classes themselves do not have callable attributes so you have to call each instance of the class separately.

Improve this answer

6 Comments

Python classes don't have callable attributes? Define what you mean considering the fact that I call my attributes all the time.
Sorry for the ambiguous language, I meant that I am pretty sure that python classes (not instances of python classes but the classes themselves) can't be used to store attributes or find the value of them. Please correct me if I am wrong
They can. If you check some of the answers below you'll see multiple instances of "static variables" associated with the class rather then the instance.
Also, your latest edit won't work. Since eat isn't declared as a static or class method you can't call Animal.eat
@MCBama I am afraid I am new to Stack Overflow and sic am unsure whether I should revert my answer
|

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.