Bummer! This is just a preview. You need to be signed in with a Basic account to view the entire video.

Preview

Start a free Basic trial
to watch this video

Sign up for Treehouse

Methods

5:48 with Kenneth Love

We can give our class some special abilities by defining methods for it.

You don't have to call the instance argument self if you don't want to. It's not a required name but it's a very common convention (I don't think I've ever seen code that didn't).

class Thief:
    sneaky = True

    def pickpocket(instance):
        if instance.sneaky:
            return bool(random.randint(0, 1))
        return False
  • 0:00

    If all we could do with classes is set and

  • 0:02

    use attributes, they wouldn't be all that useful, would they?

  • 0:04

    Like I mentioned before, though,

  • 0:05

    we can give verbs to our objects by creating methods.

  • 0:08

    Now, don't get too worried about methods, cuz I'll let you in on a secret.

  • 0:11

    Methods are just functions that belong to a class.

  • 0:13

    So, if you can write a function, you can write a method.

  • 0:16

    They do have one little gotcha, though.

  • 0:17

    So, let's get into Workspaces so I can teach you all about them.

  • 0:20

    So, I'm gonna simplify things a little bit,

  • 0:22

    I'm gonna leave out a couple of things here at first.

  • 0:24

    Methods in classes are the actions of the instances of your class can do.

  • 0:29

    For example, my Thief class might have a pickpocket method that lets it try and

  • 0:33

    snatch something out of another person's pocket.

  • 0:36

    Methods belong to the class, so they're indented inside of it,

  • 0:39

    just like attributes are.

  • 0:40

    So, we'll say def pickpocket and that'll take an argument self and

  • 0:41

    then we'll return a bool of random.randit between 0 and 1.

  • 0:41

    And that means I

  • 0:46

    need to import random.

  • 0:57

    So, what's this self thing that's going on here?

  • 1:01

    What's that about?

  • 1:02

    Well, methods are functions that's belong to a class.

  • 1:05

    Whenever they're used,

  • 1:06

    however, they're used by an instance, not by the actual class.

  • 1:11

    Because of that, methods always take at least one parameter,

  • 1:14

    which represents the instance that's using the method.

  • 1:17

    Now, by convention that parameter's always called self, but

  • 1:21

    you can call it anything you want in your own classes.

  • 1:23

    But I highly recommend you stick with self.

  • 1:26

    Now, the neat thing here is you don't give any arguments to self

  • 1:29

    when you use the method.

  • 1:31

    Let's try this out down here in our console.

  • 1:33

    So, Python from characters import Thief.

  • 1:37

    And kenneth = Thief just like before, right?

  • 1:43

    So now, I can do kenneth.pickpocket.

  • 1:47

    And just like any other function, I have to call it with parenthesis.

  • 1:50

    And since the method doesn't take any arguments other than self I don't put

  • 1:55

    anything inside of here.

  • 1:57

    And I get back False, so it randomly picked false.

  • 2:01

    So, cool.

  • 2:02

    Now, I don't usually like to show you clunky ways of achieving something but

  • 2:06

    I feel like this whole self thing needs a little bit more explanation.

  • 2:10

    Now, let's do the same method but

  • 2:12

    we're going to do it in a slightly different way, all right?

  • 2:15

    So, if I tried to Thief.pickpocket.

  • 2:19

    Then I get an error.

  • 2:20

    I get this TypeError saying that pickpocket is missing a required

  • 2:23

    positional argument, self.

  • 2:26

    Okay, so let's give it a self, pickpocket, and

  • 2:29

    I'm going to give it an instance of the class.

  • 2:33

    And this time I get False again.

  • 2:35

    So, we just ran the exact same code, but

  • 2:37

    this time we had to provide an argument to pickpocket or it failed, right?

  • 2:41

    Since we called it directly from the class,

  • 2:42

    we had to provide an instance that it would be used by.

  • 2:46

    So, let's add a little something to the class to make this instance use

  • 2:49

    more obvious.

  • 2:50

    I' m gonna go ahead and exit and them I'm gonna clear this screen.

  • 2:54

    I'm gonna hop back up here to this.

  • 2:55

    Okay, so inside pickpocket let's add a new line here,

  • 3:00

    print Called by, and then let's fill that in with self.

  • 3:05

    So, now our instance will print out who it is that's trying to pickpocket someone

  • 3:10

    else, okay?

  • 3:11

    Maybe not the best approach for a thief but

  • 3:13

    we're here to learn not to steal things from people.

  • 3:17

    So, from characters import Thief, Kenneth = Thief.

  • 3:23

    And now, let's do kenneth.pickpocket.

  • 3:27

    Okay, called by characters.Thief object at that address, and True.

  • 3:31

    Cool, that time I succeeded, all right?

  • 3:34

    So now, let's try our other method of it, Thief.pickpocket.

  • 3:38

    And we'll pass in the instance, which is kenneth.

  • 3:42

    And I get the same output, the exact same output, right?

  • 3:45

    Called by characters.thief object at 0x7f99b71edef0, all right?

  • 3:50

    Exactly same memory address.

  • 3:54

    So, the fact that we have the exact same memory address shows us that it's

  • 3:58

    using the exact same object for calling the method both times.

  • 4:03

    This self concept often trips up early programmers, but

  • 4:07

    practice makes perfect on it.

  • 4:08

    And thankfully, Python will gripe at you loudly if you forget to use self as

  • 4:12

    a parameter if you forget to call it on a method.

  • 4:17

    All right, one more thing about self.

  • 4:19

    We can always use self to talk about the current instance, like in the method.

  • 4:25

    So, let's check and

  • 4:27

    make sure that our thief is sneaky before we even attempt to pickpocket somebody.

  • 4:32

    So, let's take out this print line.

  • 4:35

    Cuz we don't need that.

  • 4:36

    And let's say if self.sneaky, and then we'll indent that.

  • 4:41

    Otherwise, we'll return False, okay?

  • 4:44

    So, if the instance's sneaky attribute is set to True,

  • 4:49

    then we'll try and pickpocket.

  • 4:51

    Otherwise, we just always return a False.

  • 4:53

    All right, so that's cool.

  • 4:55

    Now let's give that a try.

  • 4:57

    Come back down here.

  • 5:01

    From characters import thief.

  • 5:03

    kenneth = thief.

  • 5:07

    And let's try this.

  • 5:08

    So, kenneth.pickpocket.

  • 5:10

    And we get false, and if I run this another time or two I get,

  • 5:13

    yeah there we go, True, False, whatever.

  • 5:16

    Okay, so now let's make sure that I am not sneaky, all right?

  • 5:21

    I'm a clumsy non sneaky thief.

  • 5:24

    And now, let's try kenneth.pickpocket.

  • 5:28

    False, False, False, False, False, all right?

  • 5:30

    So, it's always False.

  • 5:32

    I'm gonna get caught cuz I'm not sneaky.

  • 5:36

    So, inside of a class's method, self always refers to the instance.

  • 5:40

    And I can use that to get to the instance's attributes and

  • 5:43

    even other methods.

  • 5:45

    Let's try this whole method thing out with a co-challenge or two.

You need to sign up for Treehouse in order to download course files.

Sign up