Preview

Start a free Courses trial
to watch this video

Constructicons

Name: Constructicons
Uploaded: 2017-04-19T11:40:31Z
Duration: 326 s
Description: What if we need something more complex than just a custom init or new method?

5:26 with Kenneth Love

What if we need something more complex than just a custom init or new method?

Teacher's Notes
Questions?
Video Transcript
Downloads
Workspaces

Constructors, as most classmethods would be considered, are a common sight in other languages. They're less common in Python but still really useful. I highly recommend playing around with them outside of this course and getting comfortable with them.

As for staticmethods, they're...weird. A staticmethod is a method that doesn't require an instance (self) or a class (cls). So they belong to a class because, logically, they belong there. Most of the time, though, you're better served by just creating a function in the same module as your class.

So, would it be possible to do create_bookcase without it being a classmethod? Yes and no. We could write the exact same method with a few differences, like using self instead of cls, and then leave off the decorator. We'd have to create an instance of the class first, though. It'd look something like this:

def create_bookcase(self, book_list):
    for author, title in book_list:
        self.append(Book(author, title))
    return self

We could leave off that last line, too, but it's generally a best practice to always have functions and methods return. Our use of it becomes a little weird to write out, though.

>>> Bookcase().create_bookcase([("Eric Matthes", "Crash Course Python")])

We have to create the instance first, with Bookcase() and then call the method. By using a class method, we move the instance creation into the method where it makes more sense. It's a small and fairly subtle design decision but it makes for a nicer interaction in the end.

Related Discussions

Have questions about this video? Start a discussion with the community and Treehouse staff.

Related Discussions

Have questions about this video? Start a discussion with the community and Treehouse staff.

So far, all of our methods have operated on an instance of our classes. 0:00

They're what we might call instance methods. 0:04

There's a special type of method in Python though that lets us construct an instance 0:06

of our class without having to have a class instance already. 0:09

We've seen one of them, new. 0:13

But its specialness was built into Python. 0:15

We can get this behavior on any method we want by making what's known as 0:17

a class method. 0:20

Let's check them out in WorkSpaces. 0:21

Class methods give us a slightly more interesting way to do object 0:24

instantiation. 0:27

Now while they don't replace, they init in new methods. 0:29

They often act as what's called a factory for an object. 0:32

For instance let's make a book class. 0:36

Okay, so I have a file here called books.py. 0:37

You'll wanna go ahead and make that if you don't have it. 0:39

And I'm gonna make a book, and I'm gonna make a bookcase, all right. 0:42

So bookcase. 0:47

And let's fill out book real quick. 0:50

So we'll say for the init of a book we have a title and we have an author. 0:52

And we'll say self.title = title and self.author = author. 0:57

And let's make a __str__ for this. 1:03

And we'll return that it's blah by blah. 1:08

And we'll format that with self.title and self.author cool, all right. 1:12

So now let's create our Bookcase. 1:18

So it takes self, and it takes a list of books, which we're gonna say is none. 1:22

Because you don't want to provide a mutable object 1:28

as the default argument to a argument. 1:32

So I say self dot books is equal to books. 1:37

And now let's create our class method. 1:39

So first of all we put this, and it's @classmethod. 1:42

And I'll explain what that means in just a minute. 1:49

And then we're gonna do a method here that we're gonna call create_bookcase(). 1:51

And it takes an argument called class, cls, and 1:56

it takes an argument called booklist. 1:58

books equals an empty list and for title and 1:59

author in Book list, books.append, book with the title and the author. 2:06

And then in the end, 2:15

we'll return an instance of the class with our list of books. 2:16

Now class methods don't take self as their first argument, 2:22

or the instance, or anything like that. 2:27

Instead they take the class that they're being called on and 2:29

we can't use the word class here. 2:33

We can't do class because class is a reserve key word, right? 2:35

Class has to be reserved for this. 2:42

We can't use class here. 2:44

So you'll see cls used a lot. 2:45

It's a very common abbreviation for that. 2:48

You also sometimes see klass, 2:50

that's usually used in more meta programming kind of things. 2:53

So cls is a good default. 2:56

Inside the method we're not really doing anything special. 2:59

But notice at the end that we used the class that was passed in 3:02

to create a new instance. 3:06

And we passed a list of books that we've now created. 3:07

And that'll use the class's __init__ up here to do its constructory thing. 3:10

So nice, we've encapsulated or 3:15

contained some logic to make creating a case full of books easier. 3:18

Now something you might not of seen before is this @ symbol here before classmethod. 3:23

This symbol marks classmethod as a decorator. 3:28

A decorator is more or less a function that takes another function, 3:32

does something with it, and then usually returns that function. 3:36

The class method decorator, for example, 3:40

does some modifying of the expectations of Python's object class. 3:42

Which all of our classes are inherited from, so 3:46

class methods can work how they do. 3:48

Let's try this out. 3:52

So python and we will say from books import Bookcase. 3:54

And let's make a bookcase and we won't instantiate the Bookcase. 4:02

We'll just say Bookcase.create_bookcase() and 4:06

then we pass it our list of books. 4:11

So let's say Moby-Dick by Herman Melville, 4:15

Jungle Book by Rudyard Kipling. 4:22

I have two whole books on my bookcase. 4:29

And now, if I look at Bookcase, I have this bookcase object. 4:33

And I know that this has an attribute in there called books. 4:38

So let's say bc.books and there's two books. 4:42

And let's look at book zero. 4:45

Let's do a string version of that. 4:49

And we get Moby Dick by Herman Melville, so cool. 4:54

It created the books for us and put them onto our bookcase. 4:57

There's another special type of method, 5:00

known as a static method, that doesn't require an instance or a class at all. 5:02

These methods are mostly for design purposes, 5:06

they let us put code into a class purely because it belongs with the class. 5:09

Most of the time though, 5:13

static methods can be done more cleanly as plain old functions and used scripts. 5:14

Object-Oriented Python

Constructicons

Related Discussions

Related Discussions