3

I'm just learning Python as my first programming language, and going through the this online book. My problem relates to the exercise found on that page. I'm stuck understanding how the play method works inside the class. How is it accessing all the other methods? How is getattr functioning inside this loop? Appreciate the help!

Here is the method for those that would prefer not to leave the page:

def play(self):
    next = self.start

    while True:
        print "\n--------"
        room = getattr(self, next)
        next = room()
Improve this question
2
  • You really are learning Python the hard way. ;-) I suggest using the official tutorial. Commented Jul 7, 2011 at 6:02
  • 1
    @Keith I disagree. The hard way is easier ;). Commented Jul 7, 2011 at 6:57

5 Answers 5

Reset to default
2

I'll try to explain how it works.
First, this is run:

a_game = Game("central_corridor")

This calls Game.__init__("central_corridor").
In the __init__ method, self.start takes the value "central_corridor".
Then we go back to the main body. By now, we have a variable called a_game. This variable is in fact an instance of the class Game, and it has some properties, like a_game.start, a_game.quips, a_game.death(), etc.
Next, this is run:

a_game.play()

That calls the play() method in a_game. Not in Game, but in a_game. Thus, when the method is running, it has access, through the word self (which is treated like a regular argument), to all properties of a_game.

This is run next

next = self.start

self.start was defined in __init__(), and is equal to "central_corridor". So now, next is "central_corridor".
We enter the while True: loop, print some hypens, and call getattr().
getattr() takes at least two arguments. The first one is an intsance of an object, in this case self, and the second one is the name of an attribute of that instance. In this case "central_corridor".
So getattr looks for an attribute of self that is called "central_corridor", and it finds it, and returns it. Now, room is equal to self.central_corridor.
Next, next = room() is run. As room is currently equal to self.central_corridor, this:

next = self.central_corridor()

is actually run.

self.central_corridor() can return one of "death", "laser_weapon_armory" or "central_corridor". Let's say it returns "laser_weapon_armory". Now next is "laser_weapon_armory". We go back to the beginning of the loop. We print some hyphens again, get an attribute of self named "laser_weapon_armory", which happens to be self.laser_weapon_armory, and run it.
self.laser_weapon_armory can return "the_bridge" or "death". This time let's say it returns "death". Now next is "death". We go back to the beginning of the loop, print some hypens, get self.death, and run it.

All self.death does is print a random string from self.quips, and then exit(1). The exit function, which is from the sys module, does just that. It terminates the program.

And that's pretty much it. I hope this helped.

Good luck learning Python the hard way!

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

1 Comment

Perfect explanation! That clears up what I wasn't sure about. That the value that is returned is returned to next. Thanks for taking the time to explain so thoroughly.
1

Take a look here:

http://effbot.org/zone/python-getattr.htm

Basically getattr(self, next) asks the self object to return the attribute named by next. For example if next is "abc" then it's like calling self.abc.

Improve this answer

Comments

1

Though I am uncertain as to why, it is clear that getattr() is executing whatever value is posessed in 'next'. Initially it is 'start' which is '"central_corridor". However, after that function completes and returns a value, the interaction between room() and getattr(self, next) is picking up that value and executing the corresponding function as 'next'.

EDIT:

getattr() is getting the value of the attribute, rather than the attribute itself. The value of the attribute is.... drum roll whatever the attribute returns. Which requires the attribute to fully execute in order for the value to be obtained. Then, the attribute 'next' is changed to become the return of the now-executed attribute... 'next' is then run in order to get it's value by getattr() ! Repeat until 'death' or whatever, which breaks the cycle.

I get it now.

Improve this answer

2 Comments

You are answering a question by saying "I'll answer this later." Really?
Ok, was just testing out some ideas and I found that once the code hits return it then will exit out of the loop. So if for example I reached return 'death' as in the first option after 'central_corridor' then it would exit the loop. How does this returned value of 'death' then get used to proceed to the method death?
0

It's actually very simple. :)

Think about it this way. next is assigned the reference (address) of self.next. So when we getaddr(self, next), since next is the reference of self.next, it really is just asking for the memory address of self.next which is of course an attribute of self, so it works.

I know it looks a little odd though.

A simple example for you:

>>> a = 'r'
>>> print '0x%x' % id(a)
0x7fbe99e204b8
>>> b = a
>>> print '0x%x' % id(b)
0x7fbe99e204b8

>>> class T(object): pass
... 
>>> foo = T()
>>> print '0x%x' % id(foo)
0x15c6bd0
>>> bar = foo
>>> print '0x%x' % id(bar)
0x15c6bd0
>>> bar = T()
>>> print '0x%x' % id(bar)
0x15c6b90

So basically assigning a variable to another variable just references the same object, without changing anything.

Improve this answer

Comments

0

getattr is a built-in function from python. The play method is a method that belongs to the class Game.

While True means that the loop keeps going forever till you interrupt it.

What else don't you understand?

EDIT: Ig you create a new game : g = Game() then you can call the play method : g.play() , this is what play(self) means, you can also call it this way :Game.play(g), but that is not common.

EDIT2: read more about getattr function here

Improve this answer

4 Comments

Hmm, how can I explain. I understand what you have said but I believe this is my problem. I get that when Game() first runs, it goes through init and then the play() method using central_corridor which it then runs. What I don't understand is at the end of the method when it returns 'something' where does this 'something' get returned to and where does this goto inside the loop that is still running? I guess how does the loop allow all the methods to be accessed? Hope that's clear....I have only been learning programming for a week :D
so if I understand the question correctly, this play function has a return None there when no return type is specified , the while loop runs forever till you interrupt it, on every iteration it prints "---------" , gets a new value for variable room, and sets next to that value.
Remember that this is not a program, this is a class definition so you call these methods when you run idle or any other IDE and create a game instance and call the method play on it for example.
Yes, this is just the section of program that I'm stuck on but the whole exercise program is found on my link. I just pulled out the part that I don't understand...

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.